Java MessagePack.createBufferPacker方法代码示例

import org.msgpack.MessagePack; //导入方法依赖的package包/类
public MyMessage03 testOptional0103(MyMessage01 src) throws Exception {
    MessagePack msgpack = new MessagePack();
    TemplateRegistry registry = new TemplateRegistry(null);
    ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(registry);
    Template<MyMessage01> tmpl01 = builder.buildTemplate(MyMessage01.class);
    Template<MyMessage03> tmpl03 = builder.buildTemplate(MyMessage03.class);
    BufferPacker packer = msgpack.createBufferPacker();
    tmpl01.write(packer, src);
    byte[] bytes = packer.toByteArray();
    ByteArrayInputStream in = new ByteArrayInputStream(bytes);
    Unpacker unpacker = msgpack.createUnpacker(in);
    unpacker.resetReadByteCount();
           MyMessage03 dst = tmpl03.read(unpacker, null);
           assertEquals(bytes.length, unpacker.getReadByteCount());
           return dst;
}
 

import org.msgpack.MessagePack; //导入方法依赖的package包/类
@Override
public void testMessagePackableTypeFieldsClass(
        MessagePackableTypeFieldsClass v) throws Exception {
    System.getProperties().setProperty(TemplatePrecompiler.DEST,
            "./target/test-classes");
    MessagePack msgpack = new MessagePack();
    try {
        TemplatePrecompiler.saveTemplateClass(new TemplateRegistry(null),
                MessagePackableTypeFieldsClass.class);
        Template<MessagePackableTypeFieldsClass> tmpl = msgpack
                .lookup(MessagePackableTypeFieldsClass.class);
        BufferPacker packer = msgpack.createBufferPacker();
        tmpl.write(packer, v);
        byte[] bytes = packer.toByteArray();
        BufferUnpacker unpacker = msgpack.createBufferUnpacker();
        unpacker.wrap(bytes);
        MessagePackableTypeFieldsClass ret = tmpl.read(unpacker, null);
        assertEquals(v, ret);
    } finally {
        TemplatePrecompiler
                .deleteTemplateClass(MessagePackableTypeFieldsClass.class);
        msgpack.unregister(MessagePackableTypeFieldsClass.class);
    }
}
 

import org.msgpack.MessagePack; //导入方法依赖的package包/类
@Override
   public void testMapTypeFieldsClassNotNullable(MapTypeFieldsClassNotNullable v) throws Exception {
MessagePack msgpack = new MessagePack();
TemplateRegistry registry = new TemplateRegistry(null);
ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(registry);
Template<MapTypeFieldsClassNotNullable> tmpl = builder.buildTemplate(MapTypeFieldsClassNotNullable.class);
BufferPacker packer = msgpack.createBufferPacker();
tmpl.write(packer, v);
byte[] bytes = packer.toByteArray();
BufferUnpacker unpacker = msgpack.createBufferUnpacker();
unpacker.resetReadByteCount();
unpacker.wrap(bytes);
MapTypeFieldsClassNotNullable ret = tmpl.read(unpacker, null);
assertEquals(v, ret);
assertEquals(bytes.length, unpacker.getReadByteCount());
   }
 

import org.msgpack.MessagePack; //导入方法依赖的package包/类
@Override
   public void testEnumTypeFieldsClassNotNullable(EnumTypeFieldsClassNotNullable v) throws Exception {
MessagePack msgpack = new MessagePack();
TemplateRegistry registry = new TemplateRegistry(null);
registry.register(EnumTypeFieldsClassNotNullable.SampleEnum.class,
	new OrdinalEnumTemplateBuilder(registry).buildTemplate(EnumTypeFieldsClassNotNullable.SampleEnum.class));
ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(registry);
Template<EnumTypeFieldsClassNotNullable> tmpl = builder.buildTemplate(EnumTypeFieldsClassNotNullable.class);
BufferPacker packer = msgpack.createBufferPacker();
tmpl.write(packer, v);
byte[] bytes = packer.toByteArray();
BufferUnpacker unpacker = msgpack.createBufferUnpacker();
unpacker.resetReadByteCount();
unpacker.wrap(bytes);
EnumTypeFieldsClassNotNullable ret = tmpl.read(unpacker, null);
assertEquals(v, ret);
assertEquals(bytes.length, unpacker.getReadByteCount());
   }
 

import org.msgpack.MessagePack; //导入方法依赖的package包/类
@Override
   public void testListTypeFieldsClassNotNullable(ListTypeFieldsClassNotNullable v) throws Exception {
MessagePack msgpack = new MessagePack();
TemplateRegistry registry = new TemplateRegistry(null);
ReflectionBeansTemplateBuilder builder = new ReflectionBeansTemplateBuilder(registry);
Template<ListTypeFieldsClassNotNullable> tmpl = builder.buildTemplate(ListTypeFieldsClassNotNullable.class);
BufferPacker packer = msgpack.createBufferPacker();
tmpl.write(packer, v);
byte[] bytes = packer.toByteArray();
BufferUnpacker unpacker = msgpack.createBufferUnpacker();
unpacker.resetReadByteCount();
unpacker.wrap(bytes);
ListTypeFieldsClassNotNullable ret = tmpl.read(unpacker, null);
assertEquals(v, ret);
assertEquals(bytes.length, unpacker.getReadByteCount());
   }
 

import org.msgpack.MessagePack; //导入方法依赖的package包/类
@Override
   public void testModifiersFieldsClassNotNullable(ModifiersFieldsClassNotNullable v) throws Exception {
MessagePack msgpack = new MessagePack();
TemplateRegistry registry = new TemplateRegistry(null);
ReflectionBeansTemplateBuilder builder = new ReflectionBeansTemplateBuilder(registry);
Template<ModifiersFieldsClassNotNullable> tmpl = builder.buildTemplate(ModifiersFieldsClassNotNullable.class);
BufferPacker packer = msgpack.createBufferPacker();
tmpl.write(packer, v);
byte[] bytes = packer.toByteArray();
BufferUnpacker unpacker = msgpack.createBufferUnpacker();
unpacker.resetReadByteCount();
unpacker.wrap(bytes);
ModifiersFieldsClassNotNullable ret = tmpl.read(unpacker, null);
assertEquals(v, ret);
assertEquals(bytes.length, unpacker.getReadByteCount());
   }
 

import org.msgpack.MessagePack; //导入方法依赖的package包/类
@Override
   public void testReferenceTypeFieldsClassNotNullable(ReferenceTypeFieldsClassNotNullable v) throws Exception {
MessagePack msgpack = new MessagePack();
TemplateRegistry registry = new TemplateRegistry(null);
JavassistTemplateBuilder builder = new JavassistTemplateBuilder(registry);
Template<ReferenceTypeFieldsClassNotNullable> tmpl = builder.buildTemplate(ReferenceTypeFieldsClassNotNullable.class);
BufferPacker packer = msgpack.createBufferPacker();
tmpl.write(packer, v);
byte[] bytes = packer.toByteArray();
BufferUnpacker unpacker = msgpack.createBufferUnpacker();
unpacker.resetReadByteCount();
unpacker.wrap(bytes);
ReferenceTypeFieldsClassNotNullable ret = tmpl.read(unpacker, null);
assertEquals(v, ret);
assertEquals(bytes.length, unpacker.getReadByteCount());
   }
 

import org.msgpack.MessagePack; //导入方法依赖的package包/类
@Override
   public void testReferenceCycleTypeFieldsClass(ReferenceCycleTypeFieldsClass v) throws Exception {
MessagePack msgpack = new MessagePack();
TemplateRegistry registry = new TemplateRegistry(null);
ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(registry);
Template<ReferenceCycleTypeFieldsClass> tmpl = builder.buildTemplate(ReferenceCycleTypeFieldsClass.class);
BufferPacker packer = msgpack.createBufferPacker();
tmpl.write(packer, v);
byte[] bytes = packer.toByteArray();
BufferUnpacker u = msgpack.createBufferUnpacker();
u.resetReadByteCount();
u.wrap(bytes);
Value value = u.readValue();
Converter unpacker = new Converter(value);
ReferenceCycleTypeFieldsClass ret = tmpl.read(unpacker, null);
assertEquals(v, ret);
assertEquals(bytes.length, u.getReadByteCount());
   }
 

import org.msgpack.MessagePack; //导入方法依赖的package包/类
@Override
   public void testReferenceTypeFieldsClassNotNullable(ReferenceTypeFieldsClassNotNullable v) throws Exception {
MessagePack msgpack = new MessagePack();
TemplateRegistry registry = new TemplateRegistry(null);
ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(registry);
Template<ReferenceTypeFieldsClassNotNullable> tmpl = builder.buildTemplate(ReferenceTypeFieldsClassNotNullable.class);
BufferPacker packer = msgpack.createBufferPacker();
tmpl.write(packer, v);
byte[] bytes = packer.toByteArray();
BufferUnpacker u = msgpack.createBufferUnpacker();
u.resetReadByteCount();
u.wrap(bytes);
Value value = u.readValue();
Converter unpacker = new Converter(value);
ReferenceTypeFieldsClassNotNullable ret = tmpl.read(unpacker, null);
assertEquals(v, ret);
assertEquals(bytes.length, u.getReadByteCount());
   }
 

import org.msgpack.MessagePack; //导入方法依赖的package包/类
@Override
   public void testReferenceTypeFieldsClass(ReferenceTypeFieldsClass v) throws Exception {
MessagePack msgpack = new MessagePack();
TemplateRegistry registry = new TemplateRegistry(null);
ReflectionTemplateBuilder builder = new ReflectionTemplateBuilder(registry);
Template<ReferenceTypeFieldsClass> tmpl = builder.buildTemplate(ReferenceTypeFieldsClass.class);
BufferPacker packer = msgpack.createBufferPacker();
tmpl.write(packer, v);
byte[] bytes = packer.toByteArray();
BufferUnpacker unpacker = msgpack.createBufferUnpacker();
unpacker.resetReadByteCount();
unpacker.wrap(bytes);
ReferenceTypeFieldsClass ret = tmpl.read(unpacker, null);
assertEquals(v, ret);
assertEquals(bytes.length, unpacker.getReadByteCount());
   }
 

import org.msgpack.MessagePack; //导入方法依赖的package包/类
@Override
public void testInheritanceClass(InheritanceClass v) throws Exception {
    System.getProperties().setProperty(TemplatePrecompiler.DEST,
            "./target/test-classes");
    MessagePack msgpack = new MessagePack();
    try {
        TemplatePrecompiler.saveTemplateClass(new TemplateRegistry(null),
                InheritanceClass.class);
        Template<InheritanceClass> tmpl = msgpack
                .lookup(InheritanceClass.class);
        BufferPacker packer = msgpack.createBufferPacker();
        tmpl.write(packer, v);
        byte[] bytes = packer.toByteArray();
        BufferUnpacker unpacker = msgpack.createBufferUnpacker();
        unpacker.wrap(bytes);
        InheritanceClass ret = tmpl.read(unpacker, null);
        assertEquals(v, ret);
    } finally {
        TemplatePrecompiler.deleteTemplateClass(InheritanceClass.class);
        msgpack.unregister(InheritanceClass.class);
    }
}
 

import org.msgpack.MessagePack; //导入方法依赖的package包/类
@Override
   public void testListTypeFieldsClass(ListTypeFieldsClass v) throws Exception {
MessagePack msgpack = new MessagePack();
TemplateRegistry registry = new TemplateRegistry(null);
ReflectionBeansTemplateBuilder builder = new ReflectionBeansTemplateBuilder(registry);
Template<ListTypeFieldsClass> tmpl = builder.buildTemplate(ListTypeFieldsClass.class);
BufferPacker packer = msgpack.createBufferPacker();
tmpl.write(packer, v);
byte[] bytes = packer.toByteArray();
Unpacker unpacker = msgpack.createUnpacker(new ByteArrayInputStream(bytes));
unpacker.resetReadByteCount();
ListTypeFieldsClass ret = tmpl.read(unpacker, null);
assertEquals(v, ret);
assertEquals(bytes.length, unpacker.getReadByteCount());
   }
 

import org.msgpack.MessagePack; //导入方法依赖的package包/类
@Override
   public void testReferenceTypeFieldsClassNotNullable(ReferenceTypeFieldsClassNotNullable v) throws Exception {
MessagePack msgpack = new MessagePack();
TemplateRegistry registry = new TemplateRegistry(null);
ReflectionBeansTemplateBuilder builder = new ReflectionBeansTemplateBuilder(registry);
Template<ReferenceTypeFieldsClassNotNullable> tmpl = builder.buildTemplate(ReferenceTypeFieldsClassNotNullable.class);
BufferPacker packer = msgpack.createBufferPacker();
tmpl.write(packer, v);
byte[] bytes = packer.toByteArray();
Unpacker unpacker = msgpack.createUnpacker(new ByteArrayInputStream(bytes));
unpacker.resetReadByteCount();
ReferenceTypeFieldsClassNotNullable ret = tmpl.read(unpacker, null);
assertEquals(v, ret);
assertEquals(bytes.length, unpacker.getReadByteCount());
   }
 

import org.msgpack.MessagePack; //导入方法依赖的package包/类
@Override
public void testByteBuffer(ByteBuffer v) throws Exception {
    MessagePack msgpack = new MessagePack();
    Template<ByteBuffer> tmpl = ByteBufferTemplate.instance;
    BufferPacker packer = msgpack.createBufferPacker();
    tmpl.write(packer, v);
    byte[] bytes = packer.toByteArray();
    Unpacker unpacker = msgpack.createUnpacker(new ByteArrayInputStream(bytes));
    unpacker.resetReadByteCount();
    ByteBuffer ret = tmpl.read(unpacker, null);
    assertArrayEquals(toByteArray(v), toByteArray(ret));
    assertEquals(bytes.length, unpacker.getReadByteCount());
}
 

import org.msgpack.MessagePack; //导入方法依赖的package包/类
@Override
public void testBooleanArray(boolean[] v) throws Exception {
    MessagePack msgpack = new MessagePack();
    Template<boolean[]> tmpl = BooleanArrayTemplate.instance;
    BufferPacker packer = msgpack.createBufferPacker();
    tmpl.write(packer, v);
    byte[] bytes = packer.toByteArray();
    Unpacker unpacker = msgpack.createUnpacker(new ByteArrayInputStream(bytes));
    unpacker.resetReadByteCount();
    boolean[] ret0;
    switch (index) {
    case 0:
	ret0 = null;
	break;
    case 1:
	if (v == null) {
	    ret0 = new boolean[0];
	} else {
	    ret0 = new boolean[v.length];
	}
	break;
    case 2:
	if (v == null) {
	    ret0 = new boolean[0];
	} else {
	    ret0 = new boolean[(int) v.length / 2];
	}
	break;
    default:
	throw new IllegalArgumentException();
    }
    boolean[] ret = tmpl.read(unpacker, ret0);
    assertBooleanArrayEquals(v, ret);
    assertEquals(bytes.length, unpacker.getReadByteCount());
}