mirror of
https://github.com/msgpack/msgpack-c.git
synced 2025-04-25 09:25:58 +02:00
java: refactor org.msgpack.util.codegen.*.java
This commit is contained in:
Muga Nishizawa
parent
dbb28d9a8f
commit
ad5ebd007e
@ -25,6 +25,7 @@ public class CustomMessage {
|
||||
}
|
||||
|
||||
public static void registerTemplate(Class<?> target, Template tmpl) {
|
||||
CustomPacker.register(target, tmpl);
|
||||
CustomUnpacker.register(target, tmpl);
|
||||
CustomConverter.register(target, tmpl);
|
||||
}
|
||||
|
||||
@ -33,11 +33,13 @@ public class ListTemplate implements Template {
|
||||
return elementTemplate;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public void pack(Packer pk, Object target) throws IOException {
|
||||
if(target instanceof List) {
|
||||
if(!(target instanceof List)) {
|
||||
throw new MessageTypeException();
|
||||
}
|
||||
List<Object> list = (List<Object>)target;
|
||||
pk.packArray(list.size());
|
||||
for(Object element : list) {
|
||||
elementTemplate.pack(pk, element);
|
||||
}
|
||||
|
||||
@ -39,11 +39,13 @@ public class MapTemplate implements Template {
|
||||
return valueTemplate;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public void pack(Packer pk, Object target) throws IOException {
|
||||
if(target instanceof Map) {
|
||||
if(!(target instanceof Map)) {
|
||||
throw new MessageTypeException();
|
||||
}
|
||||
Map<Object,Object> map = (Map<Object,Object>)target;
|
||||
pk.packMap(map.size());
|
||||
for(Map.Entry<Object,Object> pair : map.entrySet()) {
|
||||
keyTemplate.pack(pk, pair.getKey());
|
||||
valueTemplate.pack(pk, pair.getValue());
|
||||
|
||||
@ -72,7 +72,7 @@ public interface Constants {
|
||||
|
||||
String STATEMENT_PACKER_PACKERMETHODBODY_02 = "$1.packArray(%d); ";
|
||||
|
||||
String STATEMENT_PACKER_PACKERMETHODBODY_03 = "_$$_packers[%d].pack($1, %s_$$_t.%s%s); ";
|
||||
String STATEMENT_PACKER_PACKERMETHODBODY_03 = "_$$_templates[%d].pack($1, %s_$$_t.%s%s); ";
|
||||
|
||||
String STATEMENT_PACKER_PACKERMETHODBODY_04 = "$1.pack(((java.lang.Enum)_$$_t).ordinal()); ";
|
||||
|
||||
|
||||
@ -34,13 +34,11 @@ import javassist.CtNewMethod;
|
||||
import javassist.NotFoundException;
|
||||
|
||||
import org.msgpack.MessagePackObject;
|
||||
import org.msgpack.MessagePacker;
|
||||
import org.msgpack.MessageTypeException;
|
||||
import org.msgpack.Packer;
|
||||
import org.msgpack.Template;
|
||||
import org.msgpack.Unpacker;
|
||||
import org.msgpack.annotation.MessagePackOptional;
|
||||
import org.msgpack.packer.OptionalPacker;
|
||||
import org.msgpack.template.OptionalTemplate;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
@ -62,12 +60,9 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
|
||||
|
||||
private ConcurrentHashMap<String, Template[]> tmplCache;
|
||||
|
||||
private ConcurrentHashMap<String, MessagePacker[]> pkCache;
|
||||
|
||||
DynamicCodeGen() {
|
||||
super();
|
||||
tmplCache = new ConcurrentHashMap<String, Template[]>();
|
||||
pkCache = new ConcurrentHashMap<String, MessagePacker[]>();
|
||||
}
|
||||
|
||||
public void setTemplates(Class<?> type, Template[] tmpls) {
|
||||
@ -78,73 +73,6 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
|
||||
return tmplCache.get(type.getName());
|
||||
}
|
||||
|
||||
public void setMessagePackers(Class<?> type, MessagePacker[] pks) {
|
||||
pkCache.put(type.getName(), pks);
|
||||
}
|
||||
|
||||
public MessagePacker[] getMessagePackers(Class<?> type) {
|
||||
return pkCache.get(type.getName());
|
||||
}
|
||||
|
||||
public Class<?> generateMessagePackerClass(Class<?> origClass,
|
||||
List<FieldOption> fieldOpts) {
|
||||
try {
|
||||
LOG.debug("start generating a packer class for "
|
||||
+ origClass.getName());
|
||||
String origName = origClass.getName();
|
||||
String packerName = origName + POSTFIX_TYPE_NAME_PACKER + inc();
|
||||
checkTypeValidation(origClass);
|
||||
checkDefaultConstructorValidation(origClass);
|
||||
CtClass packerCtClass = pool.makeClass(packerName);
|
||||
setSuperclass(packerCtClass, MessagePackerAccessorImpl.class);
|
||||
setInterface(packerCtClass, MessagePacker.class);
|
||||
addClassTypeConstructor(packerCtClass);
|
||||
Field[] fields = getDeclaredFields(origClass);
|
||||
MessagePacker[] packers = null;
|
||||
if (fieldOpts != null) {
|
||||
fields = sortFields(fields, fieldOpts);
|
||||
packers = createMessagePackers(fieldOpts);
|
||||
} else {
|
||||
packers = createMessagePackers(fields);
|
||||
}
|
||||
setMessagePackers(origClass, packers);
|
||||
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);
|
||||
} catch (CannotCompileException e) {
|
||||
LOG.error(e.getMessage(), e);
|
||||
throw new DynamicCodeGenException(e.getMessage(), e);
|
||||
}
|
||||
}
|
||||
|
||||
public Class<?> generateOrdinalEnumPackerClass(Class<?> origClass) {
|
||||
try {
|
||||
LOG.debug("start generating an enum packer for "
|
||||
+ origClass.getName());
|
||||
String origName = origClass.getName();
|
||||
String packerName = origName + POSTFIX_TYPE_NAME_PACKER + inc();
|
||||
checkTypeValidation(origClass);
|
||||
CtClass packerCtClass = pool.makeClass(packerName);
|
||||
setSuperclass(packerCtClass, MessagePackerAccessorImpl.class);
|
||||
setInterface(packerCtClass, MessagePacker.class);
|
||||
addClassTypeConstructor(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);
|
||||
} catch (CannotCompileException e) {
|
||||
LOG.error(e.getMessage(), e);
|
||||
throw new DynamicCodeGenException(e.getMessage(), e);
|
||||
}
|
||||
}
|
||||
|
||||
public Class<?> generateTemplateClass(Class<?> origClass,
|
||||
List<FieldOption> fieldOpts) {
|
||||
try {
|
||||
@ -167,19 +95,18 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
|
||||
tmpls = createTemplates(fields);
|
||||
}
|
||||
setTemplates(origClass, tmpls);
|
||||
addPackMethod(tmplCtClass, origClass, fields, false);
|
||||
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) {
|
||||
DynamicCodeGenException ex = new DynamicCodeGenException(e
|
||||
.getMessage(), e);
|
||||
DynamicCodeGenException ex = new DynamicCodeGenException(e.getMessage(), e);
|
||||
LOG.error(ex.getMessage(), ex);
|
||||
throw ex;
|
||||
} catch (CannotCompileException e) {
|
||||
DynamicCodeGenException ex = new DynamicCodeGenException(e
|
||||
.getMessage(), e);
|
||||
DynamicCodeGenException ex = new DynamicCodeGenException(e.getMessage(), e);
|
||||
LOG.error(ex.getMessage(), ex);
|
||||
throw ex;
|
||||
}
|
||||
@ -196,6 +123,7 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
|
||||
setSuperclass(tmplCtClass, TemplateAccessorImpl.class);
|
||||
setInterface(tmplCtClass, Template.class);
|
||||
addClassTypeConstructor(tmplCtClass);
|
||||
addPackMethod(tmplCtClass, origClass, null, true);
|
||||
addUnpackMethod(tmplCtClass, origClass, null, true);
|
||||
addConvertMethod(tmplCtClass, origClass, null, true);
|
||||
Class<?> tmplClass = createClass(tmplCtClass);
|
||||
@ -308,38 +236,6 @@ class DynamicCodeGen extends DynamicCodeGenBase implements Constants {
|
||||
return sorted;
|
||||
}
|
||||
|
||||
MessagePacker[] createMessagePackers(List<FieldOption> fieldOpts) {
|
||||
MessagePacker[] pks = new MessagePacker[fieldOpts.size()];
|
||||
for (int i = 0; i < pks.length; ++i) {
|
||||
pks[i] = toMessagePacker(fieldOpts.get(i).tmpl);
|
||||
}
|
||||
return pks;
|
||||
}
|
||||
|
||||
MessagePacker[] createMessagePackers(Field[] fields) {
|
||||
MessagePacker[] pks = new MessagePacker[fields.length];
|
||||
for (int i = 0; i < pks.length; ++i) {
|
||||
pks[i] = createMessagePacker(fields[i]);
|
||||
}
|
||||
return pks;
|
||||
}
|
||||
|
||||
MessagePacker createMessagePacker(Field field) {
|
||||
boolean isOptional = isAnnotated(field, MessagePackOptional.class);
|
||||
Class<?> c = field.getType();
|
||||
MessagePacker pk = null;
|
||||
if (List.class.isAssignableFrom(c) || Map.class.isAssignableFrom(c)) {
|
||||
pk = createMessagePacker(field.getGenericType());
|
||||
} else {
|
||||
pk = createMessagePacker(c);
|
||||
}
|
||||
if (isOptional) {
|
||||
return new OptionalPacker(pk);
|
||||
} else {
|
||||
return pk;
|
||||
}
|
||||
}
|
||||
|
||||
Template[] createTemplates(List<FieldOption> fieldOpts) {
|
||||
Template[] tmpls = new Template[fieldOpts.size()];
|
||||
for (int i = 0; i < tmpls.length; ++i) {
|
||||
|
||||
@ -24,7 +24,6 @@ import java.lang.reflect.Method;
|
||||
import java.lang.reflect.ParameterizedType;
|
||||
import java.lang.reflect.Type;
|
||||
import java.math.BigInteger;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
@ -41,11 +40,9 @@ import javassist.NotFoundException;
|
||||
|
||||
import org.msgpack.CustomConverter;
|
||||
import org.msgpack.CustomMessage;
|
||||
import org.msgpack.CustomPacker;
|
||||
import org.msgpack.MessageConvertable;
|
||||
import org.msgpack.MessagePackObject;
|
||||
import org.msgpack.MessagePackable;
|
||||
import org.msgpack.MessagePacker;
|
||||
import org.msgpack.MessageTypeException;
|
||||
import org.msgpack.MessageUnpackable;
|
||||
import org.msgpack.Packer;
|
||||
@ -55,32 +52,6 @@ import org.msgpack.Unpacker;
|
||||
import org.msgpack.annotation.MessagePackDelegate;
|
||||
import org.msgpack.annotation.MessagePackMessage;
|
||||
import org.msgpack.annotation.MessagePackOrdinalEnum;
|
||||
import org.msgpack.packer.BigIntegerPacker;
|
||||
import org.msgpack.packer.BooleanPacker;
|
||||
import org.msgpack.packer.ByteArrayPacker;
|
||||
import org.msgpack.packer.BytePacker;
|
||||
import org.msgpack.packer.DoublePacker;
|
||||
import org.msgpack.packer.FloatPacker;
|
||||
import org.msgpack.packer.IntegerPacker;
|
||||
import org.msgpack.packer.LongPacker;
|
||||
import org.msgpack.packer.OptionalPacker;
|
||||
import org.msgpack.packer.ShortPacker;
|
||||
import org.msgpack.packer.StringPacker;
|
||||
import org.msgpack.template.BigIntegerTemplate;
|
||||
import org.msgpack.template.BooleanTemplate;
|
||||
import org.msgpack.template.ByteArrayTemplate;
|
||||
import org.msgpack.template.ByteTemplate;
|
||||
import org.msgpack.template.ClassTemplate;
|
||||
import org.msgpack.template.CollectionTemplate;
|
||||
import org.msgpack.template.DoubleTemplate;
|
||||
import org.msgpack.template.FloatTemplate;
|
||||
import org.msgpack.template.IntegerTemplate;
|
||||
import org.msgpack.template.ListTemplate;
|
||||
import org.msgpack.template.LongTemplate;
|
||||
import org.msgpack.template.MapTemplate;
|
||||
import org.msgpack.template.OptionalTemplate;
|
||||
import org.msgpack.template.ShortTemplate;
|
||||
import org.msgpack.template.StringTemplate;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
@ -89,11 +60,10 @@ public class DynamicCodeGenBase implements Constants {
|
||||
private static Logger LOG = LoggerFactory
|
||||
.getLogger(DynamicCodeGenBase.class);
|
||||
|
||||
static class MessagePackablePacker implements MessagePacker {
|
||||
@SuppressWarnings("unused")
|
||||
static class MessagePackUnpackConvertableTemplate implements Template {
|
||||
private Class<?> type;
|
||||
|
||||
MessagePackablePacker(Class<?> type) {
|
||||
MessagePackUnpackConvertableTemplate(Class<?> type) {
|
||||
this.type = type;
|
||||
}
|
||||
|
||||
@ -102,61 +72,6 @@ public class DynamicCodeGenBase implements Constants {
|
||||
MessagePackable mp = MessagePackable.class.cast(target);
|
||||
mp.messagePack(packer);
|
||||
}
|
||||
}
|
||||
|
||||
static class ListPacker implements MessagePacker {
|
||||
private MessagePacker elementPacker;
|
||||
|
||||
ListPacker(MessagePacker elementPacker) {
|
||||
this.elementPacker = elementPacker;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
@Override
|
||||
public void pack(Packer packer, Object target) throws IOException {
|
||||
List<Object> list = (List<Object>) target;
|
||||
packer.packArray(list.size());
|
||||
for (Iterator<Object> iter = list.iterator(); iter.hasNext();) {
|
||||
elementPacker.pack(packer, iter.next());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static class MapPacker implements MessagePacker {
|
||||
private MessagePacker keyPacker;
|
||||
private MessagePacker valPacker;
|
||||
|
||||
MapPacker(MessagePacker keyPacker, MessagePacker valPacker) {
|
||||
this.keyPacker = keyPacker;
|
||||
this.valPacker = valPacker;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
@Override
|
||||
public void pack(Packer packer, Object target) throws IOException {
|
||||
Map<Object, Object> map = (Map<Object, Object>) target;
|
||||
packer.packMap(map.size());
|
||||
for (Map.Entry<Object, Object> e : ((Map<Object, Object>) map)
|
||||
.entrySet()) {
|
||||
keyPacker.pack(packer, e.getKey());
|
||||
valPacker.pack(packer, e.getValue());
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
static class MessageUnpackableConvertableTemplate implements Template {
|
||||
private Class<?> type;
|
||||
|
||||
MessageUnpackableConvertableTemplate(Class<?> type) {
|
||||
this.type = type;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void pack(Packer pk, Object target) throws IOException {
|
||||
// FIXME
|
||||
pk.pack(target);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Object unpack(Unpacker unpacker) throws IOException,
|
||||
@ -192,27 +107,6 @@ public class DynamicCodeGenBase implements Constants {
|
||||
}
|
||||
}
|
||||
|
||||
public static interface MessagePackerAccessor {
|
||||
void setMessagePackers(MessagePacker[] packers);
|
||||
}
|
||||
|
||||
protected static class MessagePackerAccessorImpl implements MessagePackerAccessor {
|
||||
public Class<?> type;
|
||||
|
||||
public MessagePacker[] _$$_packers;
|
||||
|
||||
public MessagePackerAccessorImpl() {
|
||||
}
|
||||
|
||||
public MessagePackerAccessorImpl(Class<?> type) {
|
||||
this.type = type;
|
||||
}
|
||||
|
||||
public void setMessagePackers(MessagePacker[] _$$_pks) {
|
||||
_$$_packers = _$$_pks;
|
||||
}
|
||||
}
|
||||
|
||||
public static interface TemplateAccessor {
|
||||
void setTemplates(Template[] templates);
|
||||
}
|
||||
@ -342,26 +236,6 @@ public class DynamicCodeGenBase implements Constants {
|
||||
newCtClass.addConstructor(newCtCons);
|
||||
}
|
||||
|
||||
protected void addMessagePackerArrayField(CtClass newCtClass)
|
||||
throws NotFoundException, CannotCompileException {
|
||||
CtClass acsCtClass = pool
|
||||
.get(MessagePackerAccessorImpl.class.getName());
|
||||
CtField pksField = acsCtClass.getDeclaredField(VARIABLE_NAME_PACKERS);
|
||||
CtField pksField2 = new CtField(pksField.getType(), pksField.getName(),
|
||||
newCtClass);
|
||||
newCtClass.addField(pksField2);
|
||||
}
|
||||
|
||||
protected void addSetMessagePackersMethod(CtClass newCtClass)
|
||||
throws NotFoundException, CannotCompileException {
|
||||
CtClass acsCtClass = pool.get(TemplateAccessorImpl.class.getName());
|
||||
CtMethod setPksMethod = acsCtClass
|
||||
.getDeclaredMethod(METHOD_NAME_SETMESSAGEPACKERS);
|
||||
CtMethod setPksMethod2 = CtNewMethod.copy(setPksMethod, newCtClass,
|
||||
null);
|
||||
newCtClass.addMethod(setPksMethod2);
|
||||
}
|
||||
|
||||
protected void addTemplateArrayField(CtClass newCtClass)
|
||||
throws NotFoundException, CannotCompileException {
|
||||
CtClass acsCtClass = pool.get(TemplateAccessorImpl.class.getName());
|
||||
@ -422,139 +296,6 @@ public class DynamicCodeGenBase implements Constants {
|
||||
}
|
||||
}
|
||||
|
||||
public static MessagePacker toMessagePacker(Template tmpl) {
|
||||
if (tmpl instanceof BigIntegerTemplate) {
|
||||
return BigIntegerPacker.getInstance();
|
||||
} else if (tmpl instanceof BooleanTemplate) {
|
||||
return BooleanPacker.getInstance();
|
||||
} else if (tmpl instanceof ByteArrayTemplate) {
|
||||
return ByteArrayPacker.getInstance();
|
||||
} else if (tmpl instanceof ByteTemplate) {
|
||||
return BytePacker.getInstance();
|
||||
} else if (tmpl instanceof ClassTemplate) {
|
||||
UnsupportedOperationException e = new UnsupportedOperationException(
|
||||
"not supported yet.");
|
||||
LOG.error(e.getMessage(), e);
|
||||
throw e;
|
||||
} else if (tmpl instanceof CollectionTemplate) {
|
||||
UnsupportedOperationException e = new UnsupportedOperationException(
|
||||
"not supported yet.");
|
||||
LOG.error(e.getMessage(), e);
|
||||
throw e;
|
||||
} else if (tmpl instanceof DoubleTemplate) {
|
||||
return DoublePacker.getInstance();
|
||||
} else if (tmpl instanceof FloatTemplate) {
|
||||
return FloatPacker.getInstance();
|
||||
} else if (tmpl instanceof IntegerTemplate) {
|
||||
return IntegerPacker.getInstance();
|
||||
} else if (tmpl instanceof ListTemplate) {
|
||||
ListTemplate t = (ListTemplate) tmpl;
|
||||
return new ListPacker(toMessagePacker(t.getElementTemplate()));
|
||||
} else if (tmpl instanceof LongTemplate) {
|
||||
return LongPacker.getInstance();
|
||||
} else if (tmpl instanceof MapTemplate) {
|
||||
MapTemplate t = (MapTemplate) tmpl;
|
||||
return new MapPacker(toMessagePacker(t.getKeyTemplate()),
|
||||
toMessagePacker(t.getValueTemplate()));
|
||||
} else if (tmpl instanceof OptionalTemplate) {
|
||||
OptionalTemplate t = (OptionalTemplate) tmpl;
|
||||
return new OptionalPacker(toMessagePacker(t.getElementTemplate()));
|
||||
} else if (tmpl instanceof ShortTemplate) {
|
||||
return ShortPacker.getInstance();
|
||||
} else if (tmpl instanceof StringTemplate) {
|
||||
return StringPacker.getInstance();
|
||||
} else if (tmpl instanceof TemplateAccessorImpl) {
|
||||
Class<?> c = ((TemplateAccessorImpl) tmpl).type;
|
||||
if (CustomPacker.isRegistered(c)) {
|
||||
return CustomPacker.get(c);
|
||||
} else {
|
||||
MessagePacker packer = DynamicPacker.create(c);
|
||||
CustomMessage.registerPacker(c, packer);
|
||||
return packer;
|
||||
}
|
||||
}
|
||||
UnsupportedOperationException e = new UnsupportedOperationException(
|
||||
"not supported yet.");
|
||||
LOG.error(e.getMessage(), e);
|
||||
throw e;
|
||||
}
|
||||
|
||||
public static MessagePacker createMessagePacker(Type t) {
|
||||
if (t.getClass().equals(Class.class)) {
|
||||
Class<?> c = (Class<?>) t;
|
||||
if (c.equals(boolean.class) || c.equals(Boolean.class)) {
|
||||
return BooleanPacker.getInstance();
|
||||
} else if (c.equals(byte.class) || c.equals(Byte.class)) {
|
||||
return BytePacker.getInstance();
|
||||
} else if (c.equals(short.class) || c.equals(Short.class)) {
|
||||
return ShortPacker.getInstance();
|
||||
} else if (c.equals(int.class) || c.equals(Integer.class)) {
|
||||
return IntegerPacker.getInstance();
|
||||
} else if (c.equals(float.class) || c.equals(Float.class)) {
|
||||
return FloatPacker.getInstance();
|
||||
} else if (c.equals(long.class) || c.equals(Long.class)) {
|
||||
return LongPacker.getInstance();
|
||||
} else if (c.equals(double.class) || c.equals(Double.class)) {
|
||||
return DoublePacker.getInstance();
|
||||
} else if (c.equals(String.class)) {
|
||||
return StringPacker.getInstance();
|
||||
} else if (c.equals(BigInteger.class)) {
|
||||
return BigIntegerPacker.getInstance();
|
||||
} else if (CustomPacker.isRegistered(c)) {
|
||||
return CustomPacker.get(c);
|
||||
} else if (CustomMessage.isAnnotated(c, MessagePackMessage.class)) {
|
||||
// @MessagePackMessage
|
||||
MessagePacker packer = DynamicPacker.create(c);
|
||||
CustomMessage.registerPacker(c, packer);
|
||||
return packer;
|
||||
} else if (CustomMessage.isAnnotated(c, MessagePackDelegate.class)) {
|
||||
// FIXME DelegatePacker
|
||||
UnsupportedOperationException e = new UnsupportedOperationException(
|
||||
"not supported yet. : " + c.getName());
|
||||
LOG.error(e.getMessage(), e);
|
||||
throw e;
|
||||
} else if (CustomMessage.isAnnotated(c,
|
||||
MessagePackOrdinalEnum.class)) {
|
||||
// @MessagePackOrdinalEnum
|
||||
MessagePacker packer = DynamicOrdinalEnumPacker.create(c);
|
||||
CustomMessage.registerPacker(c, packer);
|
||||
return packer;
|
||||
} else if (MessagePackable.class.isAssignableFrom(c)) {
|
||||
MessagePacker packer = new MessagePackablePacker(c);
|
||||
CustomMessage.registerPacker(c, packer);
|
||||
return packer;
|
||||
} else {
|
||||
throw new MessageTypeException("Type error: "
|
||||
+ ((Class<?>) t).getName());
|
||||
}
|
||||
} else if (t instanceof GenericArrayType) {
|
||||
GenericArrayType gat = (GenericArrayType) t;
|
||||
Type gct = gat.getGenericComponentType();
|
||||
if (gct.equals(byte.class)) {
|
||||
return ByteArrayPacker.getInstance();
|
||||
} else {
|
||||
throw new DynamicCodeGenException("Not supported yet: " + gat);
|
||||
}
|
||||
} else if (t instanceof ParameterizedType) {
|
||||
ParameterizedType pt = (ParameterizedType) t;
|
||||
Class<?> rawType = (Class<?>) pt.getRawType();
|
||||
if (rawType.equals(List.class)) {
|
||||
Type[] ats = pt.getActualTypeArguments();
|
||||
return new ListPacker(createMessagePacker(ats[0]));
|
||||
} else if (rawType.equals(Map.class)) {
|
||||
Type[] ats = pt.getActualTypeArguments();
|
||||
return new MapPacker(createMessagePacker(ats[0]),
|
||||
createMessagePacker(ats[1]));
|
||||
} else {
|
||||
throw new DynamicCodeGenException("Type error: "
|
||||
+ t.getClass().getName());
|
||||
}
|
||||
} else {
|
||||
throw new DynamicCodeGenException("Type error: "
|
||||
+ t.getClass().getName());
|
||||
}
|
||||
}
|
||||
|
||||
public static Template createTemplate(Type t) {
|
||||
if (t.getClass().equals(Class.class)) {
|
||||
Class<?> c = (Class<?>) t;
|
||||
@ -576,7 +317,7 @@ public class DynamicCodeGenBase implements Constants {
|
||||
return Templates.tString();
|
||||
} else if (c.equals(BigInteger.class)) {
|
||||
return Templates.tBigInteger();
|
||||
} else if (CustomConverter.isRegistered(c)) {
|
||||
} else if (CustomConverter.isRegistered(c)) {// FIXME
|
||||
return (Template) CustomConverter.get(c);
|
||||
} else if (CustomMessage.isAnnotated(c, MessagePackMessage.class)) {
|
||||
// @MessagePackMessage
|
||||
@ -597,7 +338,7 @@ public class DynamicCodeGenBase implements Constants {
|
||||
return tmpl;
|
||||
} else if (MessageConvertable.class.isAssignableFrom(c)
|
||||
|| MessageUnpackable.class.isAssignableFrom(c)) {
|
||||
Template tmpl = new MessageUnpackableConvertableTemplate(c);
|
||||
Template tmpl = new MessagePackUnpackConvertableTemplate(c);
|
||||
CustomMessage.registerTemplate(c, tmpl);
|
||||
return tmpl;
|
||||
} else {
|
||||
|
||||
@ -17,35 +17,10 @@
|
||||
//
|
||||
package org.msgpack.util.codegen;
|
||||
|
||||
import java.lang.reflect.Constructor;
|
||||
import java.lang.reflect.InvocationTargetException;
|
||||
|
||||
import org.msgpack.MessagePacker;
|
||||
import org.msgpack.util.codegen.DynamicCodeGenBase.MessagePackerAccessor;
|
||||
|
||||
public class DynamicOrdinalEnumPacker {
|
||||
public static MessagePacker create(Class<?> c) {
|
||||
try {
|
||||
DynamicCodeGen gen = DynamicCodeGen.getInstance();
|
||||
Class<?> packerClass = gen.generateOrdinalEnumPackerClass(c);
|
||||
Constructor<?> cons = packerClass
|
||||
.getDeclaredConstructor(new Class[] { Class.class });
|
||||
Object obj = cons.newInstance(new Object[] { c });
|
||||
((MessagePackerAccessor) obj).setMessagePackers(gen
|
||||
.getMessagePackers(c));
|
||||
return (MessagePacker) obj;
|
||||
} catch (InstantiationException e) {
|
||||
throw new DynamicCodeGenException(e.getMessage(), e);
|
||||
} catch (IllegalAccessException e) {
|
||||
throw new DynamicCodeGenException(e.getMessage(), e);
|
||||
} catch (SecurityException e) {
|
||||
throw new DynamicCodeGenException(e.getMessage(), e);
|
||||
} catch (NoSuchMethodException e) {
|
||||
throw new DynamicCodeGenException(e.getMessage(), e);
|
||||
} catch (IllegalArgumentException e) {
|
||||
throw new DynamicCodeGenException(e.getMessage(), e);
|
||||
} catch (InvocationTargetException e) {
|
||||
throw new DynamicCodeGenException(e.getMessage(), e);
|
||||
}
|
||||
return DynamicOrdinalEnumTemplate.create(c);
|
||||
}
|
||||
}
|
||||
|
||||
@ -17,12 +17,9 @@
|
||||
//
|
||||
package org.msgpack.util.codegen;
|
||||
|
||||
import java.lang.reflect.Constructor;
|
||||
import java.lang.reflect.InvocationTargetException;
|
||||
import java.util.List;
|
||||
|
||||
import org.msgpack.MessagePacker;
|
||||
import org.msgpack.util.codegen.DynamicCodeGenBase.MessagePackerAccessor;
|
||||
|
||||
public class DynamicPacker {
|
||||
|
||||
@ -31,27 +28,6 @@ public class DynamicPacker {
|
||||
}
|
||||
|
||||
public static MessagePacker create(Class<?> c, List<FieldOption> fieldOpts) {
|
||||
try {
|
||||
DynamicCodeGen gen = DynamicCodeGen.getInstance();
|
||||
Class<?> packerClass = gen.generateMessagePackerClass(c, fieldOpts);
|
||||
Constructor<?> cons = packerClass
|
||||
.getDeclaredConstructor(new Class[] { Class.class });
|
||||
Object obj = cons.newInstance(new Object[] { c });
|
||||
MessagePacker[] packers = gen.getMessagePackers(c);
|
||||
((MessagePackerAccessor) obj).setMessagePackers(packers);
|
||||
return (MessagePacker) obj;
|
||||
} catch (InstantiationException e) {
|
||||
throw new DynamicCodeGenException(e.getMessage(), e);
|
||||
} catch (IllegalAccessException e) {
|
||||
throw new DynamicCodeGenException(e.getMessage(), e);
|
||||
} catch (SecurityException e) {
|
||||
throw new DynamicCodeGenException(e.getMessage(), e);
|
||||
} catch (NoSuchMethodException e) {
|
||||
throw new DynamicCodeGenException(e.getMessage(), e);
|
||||
} catch (IllegalArgumentException e) {
|
||||
throw new DynamicCodeGenException(e.getMessage(), e);
|
||||
} catch (InvocationTargetException e) {
|
||||
throw new DynamicCodeGenException(e.getMessage(), e);
|
||||
}
|
||||
return DynamicTemplate.create(c, fieldOpts);
|
||||
}
|
||||
}
|
||||
|
||||
@ -14,6 +14,7 @@ import junit.framework.TestCase;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.msgpack.CustomConverter;
|
||||
import org.msgpack.CustomMessage;
|
||||
import org.msgpack.CustomPacker;
|
||||
import org.msgpack.CustomUnpacker;
|
||||
import org.msgpack.MessageConvertable;
|
||||
@ -1233,29 +1234,23 @@ public class TestPackConvert extends TestCase {
|
||||
|
||||
@Test
|
||||
public void testNestedFieldClass00() throws Exception {
|
||||
MessagePacker packer2 = DynamicPacker.create(NestedClass.class);
|
||||
CustomPacker.register(NestedClass.class, packer2);
|
||||
MessagePacker packer1 = DynamicPacker.create(BaseClass.class);
|
||||
CustomPacker.register(BaseClass.class, packer1);
|
||||
Template tmpl2 = DynamicTemplate.create(NestedClass.class);
|
||||
CustomUnpacker.register(NestedClass.class, tmpl2);
|
||||
CustomConverter.register(NestedClass.class, tmpl2);
|
||||
Template tmpl1 = DynamicTemplate.create(BaseClass.class);
|
||||
CustomUnpacker.register(BaseClass.class, tmpl1);
|
||||
CustomConverter.register(BaseClass.class, tmpl1);
|
||||
CustomMessage.registerTemplate(NestedClass.class, tmpl2);
|
||||
Template tmpl = DynamicTemplate.create(BaseClass.class);
|
||||
CustomMessage.registerTemplate(BaseClass.class, tmpl);
|
||||
BaseClass src = new BaseClass();
|
||||
NestedClass src2 = new NestedClass();
|
||||
src.f0 = 0;
|
||||
src2.f2 = 2;
|
||||
src.f1 = src2;
|
||||
ByteArrayOutputStream out = new ByteArrayOutputStream();
|
||||
packer1.pack(new Packer(out), src);
|
||||
tmpl.pack(new Packer(out), src);
|
||||
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
|
||||
Unpacker pac = new Unpacker(in);
|
||||
Iterator<MessagePackObject> it = pac.iterator();
|
||||
assertTrue(it.hasNext());
|
||||
MessagePackObject mpo = it.next();
|
||||
BaseClass dst = (BaseClass) tmpl1.convert(mpo);
|
||||
BaseClass dst = (BaseClass) tmpl.convert(mpo);
|
||||
assertTrue(src.f0 == dst.f0);
|
||||
assertTrue(src.f1.f2 == dst.f1.f2);
|
||||
assertFalse(it.hasNext());
|
||||
@ -1263,21 +1258,13 @@ public class TestPackConvert extends TestCase {
|
||||
|
||||
@Test
|
||||
public void testNestedFieldClass02() throws Exception {
|
||||
MessagePacker packer2 = DynamicPacker.create(NestedClass.class);
|
||||
CustomPacker.register(NestedClass.class, packer2);
|
||||
MessagePacker packer = new OptionalPacker(DynamicPacker
|
||||
.create(BaseClass.class));
|
||||
CustomPacker.register(BaseClass.class, packer);
|
||||
Template tmpl2 = DynamicTemplate.create(NestedClass.class);
|
||||
CustomUnpacker.register(NestedClass.class, tmpl2);
|
||||
CustomConverter.register(NestedClass.class, tmpl2);
|
||||
Template tmpl = new OptionalTemplate(DynamicTemplate
|
||||
.create(BaseClass.class));
|
||||
CustomUnpacker.register(BaseClass.class, tmpl);
|
||||
CustomConverter.register(BaseClass.class, tmpl);
|
||||
CustomMessage.registerTemplate(NestedClass.class, tmpl2);
|
||||
Template tmpl = new OptionalTemplate(DynamicTemplate.create(BaseClass.class));
|
||||
CustomMessage.registerTemplate(BaseClass.class, tmpl);
|
||||
BaseClass src = null;
|
||||
ByteArrayOutputStream out = new ByteArrayOutputStream();
|
||||
packer.pack(new Packer(out), src);
|
||||
tmpl.pack(new Packer(out), src);
|
||||
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
|
||||
Unpacker pac = new Unpacker(in);
|
||||
Iterator<MessagePackObject> it = pac.iterator();
|
||||
@ -1305,23 +1292,17 @@ public class TestPackConvert extends TestCase {
|
||||
|
||||
@Test
|
||||
public void testOptionalNestedFieldClass00() throws Exception {
|
||||
MessagePacker packer2 = DynamicPacker.create(OptionalNestedClass.class);
|
||||
CustomPacker.register(OptionalNestedClass.class, packer2);
|
||||
MessagePacker packer = DynamicPacker.create(OptionalBaseClass.class);
|
||||
CustomPacker.register(OptionalBaseClass.class, packer);
|
||||
Template tmpl2 = DynamicTemplate.create(OptionalNestedClass.class);
|
||||
CustomUnpacker.register(OptionalNestedClass.class, tmpl2);
|
||||
CustomConverter.register(OptionalNestedClass.class, tmpl2);
|
||||
CustomMessage.registerTemplate(OptionalNestedClass.class, tmpl2);
|
||||
Template tmpl = DynamicTemplate.create(OptionalBaseClass.class);
|
||||
CustomUnpacker.register(OptionalBaseClass.class, tmpl);
|
||||
CustomConverter.register(OptionalBaseClass.class, tmpl);
|
||||
CustomMessage.registerTemplate(OptionalBaseClass.class, tmpl);
|
||||
OptionalBaseClass src = new OptionalBaseClass();
|
||||
OptionalNestedClass src2 = new OptionalNestedClass();
|
||||
src.f0 = 0;
|
||||
src2.f2 = 2;
|
||||
src.f1 = src2;
|
||||
ByteArrayOutputStream out = new ByteArrayOutputStream();
|
||||
packer.pack(new Packer(out), src);
|
||||
tmpl.pack(new Packer(out), src);
|
||||
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
|
||||
Unpacker pac = new Unpacker(in);
|
||||
Iterator<MessagePackObject> it = pac.iterator();
|
||||
@ -1335,19 +1316,13 @@ public class TestPackConvert extends TestCase {
|
||||
|
||||
@Test
|
||||
public void testOptionalNestedFieldClass01() throws Exception {
|
||||
MessagePacker packer2 = DynamicPacker.create(OptionalNestedClass.class);
|
||||
CustomPacker.register(OptionalNestedClass.class, packer2);
|
||||
MessagePacker packer = DynamicPacker.create(OptionalBaseClass.class);
|
||||
CustomPacker.register(OptionalBaseClass.class, packer);
|
||||
Template tmpl2 = DynamicTemplate.create(OptionalNestedClass.class);
|
||||
CustomUnpacker.register(OptionalNestedClass.class, tmpl2);
|
||||
CustomConverter.register(OptionalNestedClass.class, tmpl2);
|
||||
CustomMessage.registerTemplate(OptionalNestedClass.class, tmpl2);
|
||||
Template tmpl = DynamicTemplate.create(OptionalBaseClass.class);
|
||||
CustomUnpacker.register(OptionalBaseClass.class, tmpl);
|
||||
CustomConverter.register(OptionalBaseClass.class, tmpl);
|
||||
CustomMessage.registerTemplate(OptionalBaseClass.class, tmpl);
|
||||
OptionalBaseClass src = new OptionalBaseClass();
|
||||
ByteArrayOutputStream out = new ByteArrayOutputStream();
|
||||
packer.pack(new Packer(out), src);
|
||||
tmpl.pack(new Packer(out), src);
|
||||
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
|
||||
Unpacker pac = new Unpacker(in);
|
||||
Iterator<MessagePackObject> it = pac.iterator();
|
||||
|
||||
@ -11,9 +11,7 @@ import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.msgpack.CustomConverter;
|
||||
import org.msgpack.CustomPacker;
|
||||
import org.msgpack.CustomUnpacker;
|
||||
import org.msgpack.CustomMessage;
|
||||
import org.msgpack.MessagePackable;
|
||||
import org.msgpack.MessagePacker;
|
||||
import org.msgpack.MessageTypeException;
|
||||
@ -1117,23 +1115,17 @@ public class TestPackUnpack extends TestCase {
|
||||
|
||||
@Test
|
||||
public void testNestedFieldClass00() throws Exception {
|
||||
MessagePacker packer2 = DynamicPacker.create(NestedClass.class);
|
||||
CustomPacker.register(NestedClass.class, packer2);
|
||||
MessagePacker packer = DynamicPacker.create(BaseClass.class);
|
||||
CustomPacker.register(BaseClass.class, packer);
|
||||
Template tmpl2 = DynamicTemplate.create(NestedClass.class);
|
||||
CustomUnpacker.register(NestedClass.class, tmpl2);
|
||||
CustomConverter.register(NestedClass.class, tmpl2);
|
||||
CustomMessage.registerTemplate(NestedClass.class, tmpl2);
|
||||
Template tmpl = DynamicTemplate.create(BaseClass.class);
|
||||
CustomUnpacker.register(BaseClass.class, tmpl);
|
||||
CustomConverter.register(BaseClass.class, tmpl);
|
||||
CustomMessage.registerTemplate(BaseClass.class, tmpl);
|
||||
BaseClass src = new BaseClass();
|
||||
NestedClass src2 = new NestedClass();
|
||||
src.f0 = 0;
|
||||
src2.f2 = 2;
|
||||
src.f1 = src2;
|
||||
ByteArrayOutputStream out = new ByteArrayOutputStream();
|
||||
packer.pack(new Packer(out), src);
|
||||
tmpl.pack(new Packer(out), src);
|
||||
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
|
||||
BaseClass dst = (BaseClass) tmpl.unpack(new Unpacker(in));
|
||||
assertTrue(src.f0 == dst.f0);
|
||||
@ -1142,21 +1134,12 @@ public class TestPackUnpack extends TestCase {
|
||||
|
||||
@Test
|
||||
public void testNestedFieldClass01() throws Exception {
|
||||
MessagePacker packer2 = DynamicPacker.create(NestedClass.class);
|
||||
CustomPacker.register(NestedClass.class, packer2);
|
||||
MessagePacker packer = new OptionalPacker(DynamicPacker
|
||||
.create(BaseClass.class));
|
||||
CustomPacker.register(BaseClass.class, packer);
|
||||
Template tmpl2 = DynamicTemplate.create(NestedClass.class);
|
||||
CustomUnpacker.register(NestedClass.class, tmpl2);
|
||||
CustomConverter.register(NestedClass.class, tmpl2);
|
||||
Template tmpl = new OptionalTemplate(DynamicTemplate
|
||||
.create(BaseClass.class));
|
||||
CustomUnpacker.register(BaseClass.class, tmpl);
|
||||
CustomConverter.register(BaseClass.class, tmpl);
|
||||
CustomMessage.registerTemplate(NestedClass.class, tmpl2);
|
||||
Template tmpl = new OptionalTemplate(DynamicTemplate.create(BaseClass.class));
|
||||
BaseClass src = null;
|
||||
ByteArrayOutputStream out = new ByteArrayOutputStream();
|
||||
packer.pack(new Packer(out), src);
|
||||
tmpl.pack(new Packer(out), src);
|
||||
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
|
||||
BaseClass dst = (BaseClass) tmpl.unpack(new Unpacker(in));
|
||||
assertEquals(src, dst);
|
||||
@ -1179,70 +1162,47 @@ public class TestPackUnpack extends TestCase {
|
||||
|
||||
@Test
|
||||
public void testOptionalNestedFieldClass00() throws Exception {
|
||||
MessagePacker packer2 = DynamicPacker.create(OptionalNestedClass.class);
|
||||
CustomPacker.register(OptionalNestedClass.class, packer2);
|
||||
MessagePacker packer = DynamicPacker.create(OptionalBaseClass.class);
|
||||
CustomPacker.register(OptionalBaseClass.class, packer);
|
||||
Template tmpl2 = DynamicTemplate.create(OptionalNestedClass.class);
|
||||
CustomUnpacker.register(OptionalNestedClass.class, tmpl2);
|
||||
CustomConverter.register(OptionalNestedClass.class, tmpl2);
|
||||
CustomMessage.registerTemplate(OptionalNestedClass.class, tmpl2);
|
||||
Template tmpl = DynamicTemplate.create(OptionalBaseClass.class);
|
||||
CustomUnpacker.register(OptionalBaseClass.class, tmpl);
|
||||
CustomConverter.register(OptionalBaseClass.class, tmpl);
|
||||
OptionalBaseClass src = new OptionalBaseClass();
|
||||
OptionalNestedClass src2 = new OptionalNestedClass();
|
||||
src.f0 = 0;
|
||||
src2.f2 = 2;
|
||||
src.f1 = src2;
|
||||
ByteArrayOutputStream out = new ByteArrayOutputStream();
|
||||
packer.pack(new Packer(out), src);
|
||||
tmpl.pack(new Packer(out), src);
|
||||
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
|
||||
OptionalBaseClass dst = (OptionalBaseClass) tmpl
|
||||
.unpack(new Unpacker(in));
|
||||
OptionalBaseClass dst = (OptionalBaseClass) tmpl.unpack(new Unpacker(in));
|
||||
assertTrue(src.f0 == dst.f0);
|
||||
assertTrue(src.f1.f2 == dst.f1.f2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOptionalNestedFieldClass01() throws Exception {
|
||||
MessagePacker packer2 = DynamicPacker.create(OptionalNestedClass.class);
|
||||
CustomPacker.register(OptionalNestedClass.class, packer2);
|
||||
MessagePacker packer = DynamicPacker.create(OptionalBaseClass.class);
|
||||
CustomPacker.register(OptionalBaseClass.class, packer);
|
||||
Template tmpl2 = DynamicTemplate.create(OptionalNestedClass.class);
|
||||
CustomUnpacker.register(OptionalNestedClass.class, tmpl2);
|
||||
CustomConverter.register(OptionalNestedClass.class, tmpl2);
|
||||
CustomMessage.registerTemplate(OptionalNestedClass.class, tmpl2);
|
||||
Template tmpl = DynamicTemplate.create(OptionalBaseClass.class);
|
||||
CustomUnpacker.register(OptionalBaseClass.class, tmpl);
|
||||
CustomConverter.register(OptionalBaseClass.class, tmpl);
|
||||
CustomMessage.registerTemplate(OptionalBaseClass.class, tmpl);
|
||||
OptionalBaseClass src = new OptionalBaseClass();
|
||||
src.f1 = null;
|
||||
ByteArrayOutputStream out = new ByteArrayOutputStream();
|
||||
packer.pack(new Packer(out), src);
|
||||
tmpl.pack(new Packer(out), src);
|
||||
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
|
||||
OptionalBaseClass dst = (OptionalBaseClass) tmpl
|
||||
.unpack(new Unpacker(in));
|
||||
OptionalBaseClass dst = (OptionalBaseClass) tmpl.unpack(new Unpacker(in));
|
||||
assertTrue(src.f0 == dst.f0);
|
||||
assertTrue(src.f1 == dst.f1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOptionalNestedFieldClass02() throws Exception {
|
||||
MessagePacker packer2 = DynamicPacker.create(OptionalNestedClass.class);
|
||||
CustomPacker.register(OptionalNestedClass.class, packer2);
|
||||
MessagePacker packer = new OptionalPacker(DynamicPacker
|
||||
.create(OptionalBaseClass.class));
|
||||
CustomPacker.register(OptionalBaseClass.class, packer);
|
||||
Template tmpl2 = DynamicTemplate.create(OptionalNestedClass.class);
|
||||
CustomUnpacker.register(OptionalNestedClass.class, tmpl2);
|
||||
CustomConverter.register(OptionalNestedClass.class, tmpl2);
|
||||
Template tmpl = new OptionalTemplate(DynamicTemplate
|
||||
.create(OptionalBaseClass.class));
|
||||
CustomUnpacker.register(OptionalBaseClass.class, tmpl);
|
||||
CustomConverter.register(OptionalBaseClass.class, tmpl);
|
||||
CustomMessage.registerTemplate(OptionalNestedClass.class, tmpl2);
|
||||
Template tmpl = new OptionalTemplate(DynamicTemplate.create(OptionalBaseClass.class));
|
||||
CustomMessage.registerTemplate(OptionalBaseClass.class, tmpl);
|
||||
OptionalBaseClass src = null;
|
||||
ByteArrayOutputStream out = new ByteArrayOutputStream();
|
||||
packer.pack(new Packer(out), src);
|
||||
tmpl.pack(new Packer(out), src);
|
||||
ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
|
||||
OptionalBaseClass dst = (OptionalBaseClass) tmpl
|
||||
.unpack(new Unpacker(in));
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user