Java TypeSerializer.serialize方法代码示例

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializer; //导入方法依赖的package包/类
@Override
public void serialize(TypeToken<?> type, Multimap obj, ConfigurationNode node) throws ObjectMappingException {
    TypeToken<?> key = type.resolveType(Multimap.class.getTypeParameters()[0]);
    TypeToken<?> value = type.resolveType(Multimap.class.getTypeParameters()[1]);
    TypeSerializer keySerial = node.getOptions().getSerializers().get(key);
    TypeSerializer valueSerial = node.getOptions().getSerializers().get(value);

    if (keySerial == null) {
        throw new ObjectMappingException("No type serializer available for type " + key);
    }

    if (valueSerial == null) {
        throw new ObjectMappingException("No type serializer available for type " + value);
    }

    node.setValue(ImmutableMap.of());
    for (Object k : obj.keySet()) {
        for (Object v : obj.get(k)) {
            SimpleConfigurationNode keyNode = SimpleConfigurationNode.root();
            keySerial.serialize(key, k, keyNode);
            valueSerial.serialize(value, v, node.getNode(keyNode.getValue()));
        }
    }
}
 

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializer; //导入方法依赖的package包/类
@SuppressWarnings("rawtypes")
public void serializeTo(Object instance, ConfigurationNode node) throws ObjectMappingException {
    try {
        Object fieldVal = this.field.get(instance);
        if (fieldVal == null) {
            node.setValue(null);
        } else {
            TypeSerializer serial = node.getOptions().getSerializers().get(this.fieldType);
            if (serial == null) {
                throw new ObjectMappingException("No TypeSerializer found for field " + field.getName() + " of type "
                        + this.fieldType);
            }
            serial.serialize(this.fieldType, fieldVal, node);
        }

        if (node instanceof CommentedConfigurationNode && this.comment != null && !this.comment.isEmpty()) {
            CommentedConfigurationNode commentNode = ((CommentedConfigurationNode) node);
            if (!commentNode.getComment().isPresent()) {
                commentNode.setComment(this.comment);
            }
        }
    } catch (IllegalAccessException e) {
        throw new ObjectMappingException("Unable to serialize field " + field.getName(), e);
    }

}
 

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializer; //导入方法依赖的package包/类
/**
 * Set this node's value to the given value.
 * If the provided value is a {@link java.util.Collection} or a {@link java.util.Map}, it will be unwrapped into
 * the appropriate configuration node structure.
 * This method will also perform serialization using the appropriate TypeSerializer for the given type, or casting if no type serializer is found.
 *
 * @param type The type to use for serialization type information
 * @param value The value to set
 * @param <T> The type to serialize to
 * @return this
 */
default <T> ConfigurationNode setValue(TypeToken<T> type, T value) throws ObjectMappingException {
    if (value == null) {
        setValue(null);
        return this;
    }
    TypeSerializer serial = getOptions().getSerializers().get(type);
    if (serial != null) {
        serial.serialize(type, value, this);
    } else if (getOptions().acceptsType(value.getClass())) {
        setValue(value); // Just write if no applicable serializer exists?
    } else {
        throw new ObjectMappingException("No serializer available for type " + type);
    }
    return this;
}
 

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializer; //导入方法依赖的package包/类
@Test
public void testNumberSerializer() throws ObjectMappingException {
    final TypeToken<Integer> intType = TypeToken.of(Integer.class);
    final TypeToken<Long> longType = TypeToken.of(Long.class);
    final TypeToken<Float> floatType = TypeToken.of(Float.class);
    final TypeToken<?> primitiveIntType = TypeToken.of(int.class);

    // They must all be the same serializer
    final TypeSerializer<Integer> numberSerializer = SERIALIZERS.get(intType);
    assertEquals(numberSerializer, SERIALIZERS.get(longType));
    assertEquals(numberSerializer, SERIALIZERS.get(floatType));
    assertEquals(numberSerializer, SERIALIZERS.get(primitiveIntType));

    SimpleConfigurationNode node = SimpleConfigurationNode.root().setValue(45f);
    assertEquals((Object) 45, numberSerializer.deserialize(intType, node));
    assertEquals((Object) 45L, numberSerializer.deserialize(longType, node));
    assertEquals((Object) 45f, numberSerializer.deserialize(floatType, node));
    assertEquals((Object) 45, numberSerializer.deserialize(primitiveIntType, node));

    numberSerializer.serialize(intType, 42, node);
    assertEquals(42, node.getValue());
}
 

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializer; //导入方法依赖的package包/类
@Test
public void testListSerializer() throws ObjectMappingException {
    final TypeToken<List<String>> stringListType = new TypeToken<List<String>>() {};
    final TypeSerializer<List<String>> stringListSerializer = SERIALIZERS.get(stringListType);
    final ConfigurationNode value = SimpleConfigurationNode.root();
    value.getAppendedNode().setValue("hi");
    value.getAppendedNode().setValue("there");
    value.getAppendedNode().setValue("beautiful");
    value.getAppendedNode().setValue("people");

    assertEquals(Arrays.asList("hi", "there", "beautiful", "people"), stringListSerializer.deserialize(stringListType, value));
    value.setValue(null);

    stringListSerializer.serialize(stringListType, Arrays.asList("hi", "there", "lame", "people"), value);
    assertEquals("hi", value.getNode(0).getString());
    assertEquals("there", value.getNode(1).getString());
    assertEquals("lame", value.getNode(2).getString());
    assertEquals("people", value.getNode(3).getString());
}
 

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializer; //导入方法依赖的package包/类
@Test
public void testMapSerializer() throws ObjectMappingException {
    final TypeToken<Map<String, Integer>> mapStringIntType = new TypeToken<Map<String, Integer>>() {};
    final TypeSerializer<Map<String, Integer>> mapStringIntSerializer =
            SERIALIZERS.get(mapStringIntType);

    final ConfigurationNode value = SimpleConfigurationNode.root();
    value.getNode("fish").setValue(5);
    value.getNode("bugs").setValue("124880");
    value.getNode("time").setValue("-1");

    final Map<String, Integer> expectedValues = ImmutableMap.of("fish", 5, "bugs", 124880, "time", -1);

    assertEquals(expectedValues, mapStringIntSerializer.deserialize(mapStringIntType, value));

    value.setValue(null);

    mapStringIntSerializer.serialize(mapStringIntType, expectedValues, value);
    assertEquals(5, value.getNode("fish").getInt());
    assertEquals(124880, value.getNode("bugs").getInt());
    assertEquals(-1, value.getNode("time").getInt());
}
 

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializer; //导入方法依赖的package包/类
@Test
public void testInvalidMapValueTypes() throws ObjectMappingException {
    final TypeToken<Map<TestEnum, Integer>> mapTestEnumIntType = new TypeToken<Map<TestEnum, Integer>>() {};
    final TypeSerializer<Map<TestEnum, Integer>> mapTestEnumIntSerializer =
            SERIALIZERS.get(mapTestEnumIntType);

    final ConfigurationNode value = SimpleConfigurationNode.root();
    value.getNode("FIRST").setValue(5);
    value.getNode("SECOND").setValue(8);

    Map<TestEnum, Integer> des = mapTestEnumIntSerializer.deserialize(mapTestEnumIntType, value);
    final ConfigurationNode serialVal = SimpleConfigurationNode.root();
    mapTestEnumIntSerializer.serialize(mapTestEnumIntType, des, serialVal);
    assertEquals(value.getValue(), serialVal.getValue());
    //assertEquals(value, serialVal);
}
 

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializer; //导入方法依赖的package包/类
@Test
public void testMapSerializerRemovesDeletedKeys() throws ObjectMappingException {
    final TypeToken<Map<String, Integer>> mapStringIntType = new TypeToken<Map<String, Integer>>() {};
    final TypeSerializer<Map<String, Integer>> mapStringIntSerializer = SERIALIZERS.get(mapStringIntType);

    final ConfigurationNode value = SimpleConfigurationNode.root();
    value.getNode("fish").setValue(5);
    value.getNode("bugs").setValue("124880");
    value.getNode("time").setValue("-1");

    @SuppressWarnings("unchecked")
    final Map<String, Integer> deserialized = mapStringIntSerializer.deserialize(mapStringIntType, value);
    deserialized.remove("fish");

    mapStringIntSerializer.serialize(mapStringIntType, deserialized, value);
    assertTrue(value.getNode("fish").isVirtual());
    assertFalse(value.getNode("bugs").isVirtual());
}
 

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializer; //导入方法依赖的package包/类
@Test
public void testStringSerializer() throws ObjectMappingException {
    final TypeToken<String> stringType = TypeToken.of(String.class);
    final TypeSerializer<String> stringSerializer = SERIALIZERS.get(stringType);
    final ConfigurationNode node = SimpleConfigurationNode.root().setValue("foobar");

    assertEquals("foobar", stringSerializer.deserialize(stringType, node));
    stringSerializer.serialize(stringType, "foobarbaz", node);
    assertEquals("foobarbaz", node.getString());
}
 

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializer; //导入方法依赖的package包/类
@Test
public void testListSerializerPreservesEmptyList() throws ObjectMappingException {
    final TypeToken<List<String>> listStringType = new TypeToken<List<String>>() {};
    final TypeSerializer<List<String>> listStringSerializer =
            SERIALIZERS.get(listStringType);

    final ConfigurationNode value = SimpleConfigurationNode.root();

    listStringSerializer.serialize(listStringType, ImmutableList.of(), value);

    assertTrue(value.hasListChildren());
}
 

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializer; //导入方法依赖的package包/类
@Test
public void testMapSerializerPreservesEmptyMap() throws ObjectMappingException {
    final TypeToken<Map<String, Integer>> mapStringIntType = new TypeToken<Map<String, Integer>>() {};
    final TypeSerializer<Map<String, Integer>> mapStringIntSerializer =
            SERIALIZERS.get(mapStringIntType);

    final ConfigurationNode value = SimpleConfigurationNode.root();

    mapStringIntSerializer.serialize(mapStringIntType, ImmutableMap.of(), value);

    assertTrue(value.hasMapChildren());
}
 

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializer; //导入方法依赖的package包/类
@Test
public void testURISerializer() throws ObjectMappingException {
     final TypeToken<URI> uriType = TypeToken.of(URI.class);
     final TypeSerializer<URI> uriSerializer = SERIALIZERS.get(uriType);

     final String uriString = "http://google.com";
     final URI testUri = URI.create(uriString);

     SimpleConfigurationNode node = SimpleConfigurationNode.root().setValue(uriString);
     assertEquals(testUri, uriSerializer.deserialize(uriType, node));

     uriSerializer.serialize(uriType, testUri, node);
     assertEquals(uriString, node.getValue());
}
 

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializer; //导入方法依赖的package包/类
@Test
public void testURLSerializer() throws ObjectMappingException, MalformedURLException {
     final TypeToken<URL> urlType = TypeToken.of(URL.class);
     final TypeSerializer<URL> urlSerializer = SERIALIZERS.get(urlType);

     final String urlString = "http://google.com";
     final URL testUrl = new URL(urlString);

     SimpleConfigurationNode node = SimpleConfigurationNode.root().setValue(urlString);
     assertEquals(testUrl, urlSerializer.deserialize(urlType, node));

     urlSerializer.serialize(urlType, testUrl, node);
     assertEquals(urlString, node.getValue());
}
 

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializer; //导入方法依赖的package包/类
@Test
public void testUUIDSerializer() throws ObjectMappingException {
    final TypeToken<UUID> uuidType = TypeToken.of(UUID.class);
    final TypeSerializer<UUID> uuidSerializer = SERIALIZERS.get(uuidType);

    final UUID testUuid = UUID.randomUUID();

    SimpleConfigurationNode serializeTo = SimpleConfigurationNode.root();
    uuidSerializer.serialize(uuidType, testUuid, serializeTo);
    assertEquals(testUuid.toString(), serializeTo.getValue());

    assertEquals(testUuid, uuidSerializer.deserialize(uuidType, serializeTo));

}
 

import ninja.leaping.configurate.objectmapping.serialize.TypeSerializer; //导入方法依赖的package包/类
@Test
public void testPatternSerializer() throws ObjectMappingException {
    final TypeToken<Pattern> patternType = TypeToken.of(Pattern.class);
    final TypeSerializer<Pattern> patternSerializer = SERIALIZERS.get(patternType);

    final Pattern testPattern = Pattern.compile("(na )+batman");
    SimpleConfigurationNode serializeTo = SimpleConfigurationNode.root();
    patternSerializer.serialize(patternType, testPattern, serializeTo);
    assertEquals("(na )+batman", serializeTo.getValue());
    assertEquals(testPattern.pattern(), patternSerializer.deserialize(patternType, serializeTo).pattern());
}