@Override public Object getValue() { Map<Object, Object> value = new LinkedHashMap<>(); for (Map.Entry<Object, ? extends SimpleConfigurationNode> ent : values.entrySet()) { value.put(ent.getKey(), ent.getValue().getValue()); } return value; }
@Override public Object getValue() { final List<SimpleConfigurationNode> values = this.values.get(); synchronized (values) { final List<Object> ret = new ArrayList<>(values.size()); for (SimpleConfigurationNode obj : values) { ret.add(obj.getValue()); } return ret.isEmpty() ? null : ret; } }
@Nullable @Override public Object getValue() { final List<SimpleConfigurationNode> values = this.values.get(); synchronized (values) { final List<Object> ret = new ArrayList<>(values.size()); for (SimpleConfigurationNode obj : values) { ret.add(obj.getValue()); // unwrap } return ret; } }
@Nullable @Override public Object getValue() { final List<SimpleConfigurationNode> values = this.values.get(); synchronized (values) { final List<Object> ret = new ArrayList<>(values.size()); for (SimpleConfigurationNode obj : values) { ret.add(obj.getValue()); // unwrap } return ret; } }
@Nullable @Override public Object getValue() { Map<Object, Object> value = new LinkedHashMap<>(); for (Map.Entry<Object, ? extends SimpleConfigurationNode> ent : values.entrySet()) { value.put(ent.getKey(), ent.getValue().getValue()); // unwrap key from the backing node } return value; }
@Override public <T> T getValue(Function<Object, T> transformer, T def) { T ret = transformer.apply(getValue()); return ret == null ? calculateDef(def) : ret; }
@Override public <T> T getValue(Function<Object, T> transformer, Supplier<T> defSupplier) { T ret = transformer.apply(getValue()); return ret == null ? calculateDef(defSupplier.get()) : ret; }
@Override public <T> List<T> getList(TypeToken<T> type, Supplier<List<T>> defSupplier) throws ObjectMappingException { List<T> ret = getValue(new TypeToken<List<T>>() {} .where(new TypeParameter<T>() {}, type), defSupplier); return ret.isEmpty() ? calculateDef(defSupplier.get()) : ret; }
@Override public <T> T getValue(@NonNull Function<Object, T> transformer, T def) { T ret = transformer.apply(getValue()); return ret == null ? storeDefault(def) : ret; }
@Override public <T> List<T> getList(TypeToken<T> type, List<T> def) throws ObjectMappingException { List<T> ret = getValue(new TypeToken<List<T>>() {} .where(new TypeParameter<T>() {}, type), def); return ret.isEmpty() ? calculateDef(def) : ret; }
@Override public <T> T getValue(@NonNull Function<Object, T> transformer, T def) { T ret = transformer.apply(getValue()); return ret == null ? storeDefault(def) : ret; }
@Override public <T> T getValue(@NonNull Function<Object, T> transformer, @NonNull Supplier<T> defSupplier) { T ret = transformer.apply(getValue()); return ret == null ? storeDefault(defSupplier.get()) : ret; }
@Override public <T> List<T> getList(@NonNull TypeToken<T> type, List<T> def) throws ObjectMappingException { List<T> ret = getValue(new TypeToken<List<T>>() {} .where(new TypeParameter<T>() {}, type), def); return ret.isEmpty() ? storeDefault(def) : ret; }
@Override public <T> List<T> getList(@NonNull TypeToken<T> type, @NonNull Supplier<List<T>> defSupplier) throws ObjectMappingException { List<T> ret = getValue(new TypeToken<List<T>>(){}.where(new TypeParameter<T>(){}, type), defSupplier); return ret.isEmpty() ? storeDefault(defSupplier.get()) : ret; }
@Override public <T> List<T> getList(@NonNull TypeToken<T> type, @NonNull Supplier<List<T>> defSupplier) throws ObjectMappingException { List<T> ret = getValue(new TypeToken<List<T>>(){}.where(new TypeParameter<T>(){}, type), defSupplier); return ret.isEmpty() ? storeDefault(defSupplier.get()) : ret; }
@Test public void testGetSetValueSerialized() throws ObjectMappingException { SimpleConfigurationNode subject = SimpleConfigurationNode.root(); subject.setValue("48"); assertEquals((Object) 48, subject.getValue(TypeToken.of(Integer.class))); UUID testId = UUID.randomUUID(); subject.setValue(TypeToken.of(UUID.class), testId); assertEquals(testId.toString(), subject.getValue()); }
@Test public void testDefaultsCopied() { SimpleConfigurationNode subject = SimpleConfigurationNode.root(ConfigurationOptions.defaults().setShouldCopyDefaults(true)); assertNull(subject.getValue()); assertEquals("default value", subject.getValue("default value")); assertEquals("default value", subject.getValue()); }
@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)); }
@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()); }
@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()); }