Map serialization cannot find templates for Object classes

[mgenov]

Hello,
It seems that map serialization fails when Map contains an Object values. Here is the full stack trace and the code that is causing this error:

org.msgpack.MessageTypeException: Cannot find template for class java.lang.Object class. Try to add @message annotation to the class or call MessagePack.register(Type).
at org.msgpack.template.TemplateRegistry.lookup(TemplateRegistry.java:220)
at org.msgpack.template.TemplateRegistry.lookupGenericTypeImpl(TemplateRegistry.java:258)
at org.msgpack.template.TemplateRegistry.lookupGenericType(TemplateRegistry.java:230)
at org.msgpack.template.TemplateRegistry.lookup(TemplateRegistry.java:180)

package com.mycompany.app;

import org.junit.Test;
import org.msgpack.MessagePack;
import org.msgpack.annotation.Message;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import static junit.framework.Assert.assertEquals;

/**
 * Verifies whether object that contains map string -> object could be serialized.
 */
public class SerializeEntityWithMapTest {

  @Message
  public static class Entity {
    public String name;
    public Map<String, Object> properties = new HashMap<String, Object>();
  }

  @Test
  public void happyPath() throws IOException {
    MessagePack pack = new MessagePack();

    Entity e = new Entity();
    e.name = "test";
    e.properties.put("Test","aaaa");

    byte[] content = pack.write(e);

    Entity actual = new MessagePack().read(content, Entity.class);

    System.out.println(actual.properties);
    assertEquals(1,actual.properties.size());
  }
}

[muga]

Yes, MessagePack doesn't allow users to serialize variables of java.lang.Object type. Can you replace type of properties with Map<String, String> in your program? If you can do that, you can serialize Entity objects.

[mgenov]

In my case it's not possible. My general idea is to store only primitive types + List or Set of primitive types, not another entities.

String, Integer, Long, Double, Date, List<String I Integer | Long | Double | Date>, Set<String | Integer, Long, Double, Date> 

Any ideas?

[muga]

As another idea, you can implement serializer and deserializer for Entity objects like following EntityTemplate class. toObject method allows you to deserialize data to various types of variables. But, the method doesn't enable identifying whether serialized data is int variables or long ones. This is because of specification of MessagePack's type system.
http://wiki.msgpack.org/display/MSGPACK/Format+specification

I hope for your help.

import org.msgpack.MessagePack;
import org.msgpack.annotation.Message;
import org.msgpack.packer.Packer;
import org.msgpack.template.AbstractTemplate;
import org.msgpack.template.Template;
import org.msgpack.template.Templates;
import org.msgpack.type.ArrayValue;
import org.msgpack.type.FloatValue;
import org.msgpack.type.IntegerValue;
import org.msgpack.type.RawValue;
import org.msgpack.type.Value;
import org.msgpack.unpacker.Converter;
import org.msgpack.unpacker.Unpacker;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Verifies whether object that contains map string -> object could be serialized.
 */
public class SerializeEntityWithMapTest {

    @Message
    public static class Entity {
    public String name;
    public Map<String, Object> properties = new HashMap<String, Object>();
    }

    public static class EntityTemplate extends AbstractTemplate<Entity> {
    @Override
    public void write(Packer pk, Entity v, boolean required)
        throws IOException {
        if (v == null) {
        if (required) {
            throw new NullPointerException();
        }
        pk.writeNil();
        return;
        }
        // serialize entity object
        pk.writeArrayBegin(2);
        {
        // serialize 1st field "name"
        pk.write(v.name);
        // serialize 2nd field "properties"
        pk.writeMapBegin(v.properties.size());
        {
            // serialize each pair of key and value
            for (Map.Entry<String, Object> e : v.properties.entrySet()) {
            String key = e.getKey();
            pk.write(key);
            Object val = e.getValue();
            pk.write(val);
            }
        }
        pk.writeMapEnd();
        }
        pk.writeArrayEnd();
    }

    @Override
    public Entity read(Unpacker u, Entity to, boolean required)
        throws IOException {
        if (!required && u.trySkipNil()) {
        return null;
        }
        if (to == null) {
        to = new Entity();
        }
        // deserialize entity object
        u.readArrayBegin();
        {
        // deserialize 1st field "name"
        to.name = u.read(Templates.TString);
        // deserialize 2nd field "properties"
        int size = u.readMapBegin();
        to.properties = new HashMap<String, Object>();
        {
            // deserialize each pair of key and value
            for (int i = 0; i < size; i++) {
            // deserialize key
            String key = u.read(Templates.TString);
            // deserialize value
            Object val = toObject(u.readValue());
            to.properties.put(key, val);
            }
        }
        u.readMapEnd();
        }
        u.readArrayEnd();
        return to;
    }

    private static Object toObject(Value value) throws IOException {
        Converter conv = new Converter(value);
        if (value.isNilValue()) { // null
        return null;
        } else if (value.isRawValue()) { // byte[] or String or maybe Date?
        // deserialize value to String object
        RawValue v = value.asRawValue();
        return conv.read(Templates.TString);
        } else if (value.isBooleanValue()) { // boolean
        return conv.read(Templates.TBoolean);
        } else if (value.isIntegerValue()) { // int or long or BigInteger
        // deserialize value to int
        IntegerValue v = value.asIntegerValue();
        return conv.read(Templates.TInteger);
        } else if (value.isFloatValue()) { // float or double
        // deserialize value to double
        FloatValue v = value.asFloatValue();
        return conv.read(Templates.TDouble);
        } else if (value.isArrayValue()) { // List or Set
        // deserialize value to List object
        ArrayValue v = value.asArrayValue();
        List<Object> ret = new ArrayList<Object>(v.size());
        for (Value elementValue : v) {
            ret.add(toObject(elementValue));
        }
        return ret;
        } else if (value.isMapValue()) { // Map
        // deserialize value to Map object
        throw new UnsupportedOperationException(); // FIXME
        } else {
        throw new RuntimeException("fatal error");
        }
    }
    }

    public static void main(String[] args) throws Exception {
    Entity src = new Entity();
    src.name = "test";
    // String, Integer, Long, Double, Date,
    // List<String | Integer | Long | Double | Date>
    // Set<String | Integer, Long, Double, Date>
    src.properties.put("string", "aaaa");
    src.properties.put("integer", 10);
    src.properties.put("long", 10L);
    src.properties.put("double", 100.1);
    List<Object> list = new ArrayList<Object>();
    list.add("bbb");
    list.add(20);
    src.properties.put("list", list);

    MessagePack msgpack = new MessagePack();
    Template<Entity> tmpl = new EntityTemplate();
    // serialize
    byte[] bytes = msgpack.write(src, tmpl);
    // deserialize
    Entity dst = msgpack.read(bytes, tmpl);
    System.out.println(dst.properties);
    }
}

[hangsucho]

else if (value.isMapValue()) { // Map
// deserialize value to Map object
MapValue v = value.asMapValue();
Map<String, Object> ret = new HashMap<String, Object>();
for (Value key : v.keySet()) {
ret.put(new Converter(key).read(Templates.TString), toObject(v.get(key)));
}
return ret;

[rmckinnon]

I modified the toObject method to address the "isMapValue" condition:

private static Object toObject(Value value) throws IOException {
    Converter conv = new Converter(value);
    if (value.isNilValue()) { // null
        return null;
    } else if (value.isRawValue()) { // byte[] or String or maybe Date?
        // deserialize value to String object
        RawValue v = value.asRawValue();
        return conv.read(Templates.TString);
    } else if (value.isBooleanValue()) { // boolean
        return conv.read(Templates.TBoolean);
    } else if (value.isIntegerValue()) { // int or long or BigInteger
        // deserialize value to int
        IntegerValue v = value.asIntegerValue();
        return conv.read(Templates.TInteger);
    } else if (value.isFloatValue()) { // float or double
        // deserialize value to double
        FloatValue v = value.asFloatValue();
        return conv.read(Templates.TDouble);
    } else if (value.isArrayValue()) { // List or Set
        // deserialize value to List object
        ArrayValue v = value.asArrayValue();
        List<Object> ret = new ArrayList<Object>(v.size());
        for (Value elementValue : v) {
            ret.add(toObject(elementValue));
        }
        return ret;
    } else if (value.isMapValue()) { // Map
        // deserialize value to Map object
        MapValue mv = value.asMapValue();
        Map<String, Object> map = new LinkedHashMap<String, Object>();
        for (Value key: mv.keySet()) {
            map.put(new Converter(key).read(Templates.TString), toObject(mv.get(key)));
        }

        return map;
    } else {
        throw new RuntimeException("fatal error");
    }
}