private void generateArray(JsonGenerator generator, ConfigurationNode node) throws IOException { if (!node.hasListChildren()) { throw new IOException("Node passed to generateArray does not have list children!"); } List<? extends ConfigurationNode> children = node.getChildrenList(); generator.writeStartArray(children.size()); for (ConfigurationNode child : children) { //generateComment(generator, child, true); generateValue(generator, child); } generator.writeEndArray(); } }
private static void generateArray(JsonGenerator generator, ConfigurationNode node) throws IOException { if (!node.hasListChildren()) { throw new IOException("Node passed to generateArray does not have list children!"); } List<? extends ConfigurationNode> children = node.getChildrenList(); generator.writeStartArray(children.size()); for (ConfigurationNode child : children) { //generateComment(generator, child, true); generateValue(generator, child); } generator.writeEndArray(); } }
private static void generateValue(JsonWriter generator, ConfigurationNode node) throws IOException { if (node.hasMapChildren()) { generateObject(generator, node); } else if (node.hasListChildren()) { generateArray(generator, node); } else if (node.getKey() == null && node.getValue() == null) { generator.beginObject(); generator.endObject(); } else { Object value = node.getValue(); if (value instanceof Double) { generator.value((Double) value); } else if (value instanceof Float) { generator.value((Float) value); } else if (value instanceof Long) { generator.value((Long) value); } else if (value instanceof Integer) { generator.value((Integer) value); } else if (value instanceof Boolean) { generator.value((Boolean) value); } else { generator.value(value.toString()); } } }
private static void generateArray(JsonWriter generator, ConfigurationNode node) throws IOException { if (!node.hasListChildren()) { throw new IOException("Node passed to generateArray does not have list children!"); } List<? extends ConfigurationNode> children = node.getChildrenList(); generator.beginArray(); for (ConfigurationNode child : children) { generateValue(generator, child); } generator.endArray(); } }
private static void generateArray(JsonWriter generator, ConfigurationNode node) throws IOException { if (!node.hasListChildren()) { throw new IOException("Node passed to generateArray does not have list children!"); } List<? extends ConfigurationNode> children = node.getChildrenList(); generator.beginArray(); for (ConfigurationNode child : children) { generateValue(generator, child); } generator.endArray(); } }
private static void generateValue(JsonWriter generator, ConfigurationNode node) throws IOException { if (node.hasMapChildren()) { generateObject(generator, node); } else if (node.hasListChildren()) { generateArray(generator, node); } else if (node.getKey() == null && node.getValue() == null) { generator.beginObject(); generator.endObject(); } else { Object value = node.getValue(); if (value instanceof Double) { generator.value((Double) value); } else if (value instanceof Float) { generator.value((Float) value); } else if (value instanceof Long) { generator.value((Long) value); } else if (value instanceof Integer) { generator.value((Integer) value); } else if (value instanceof Boolean) { generator.value((Boolean) value); } else { generator.value(value.toString()); } } }
private void generateArray(JsonWriter generator, ConfigurationNode node) throws IOException { if (!node.hasListChildren()) { throw new IOException("Node passed to generateArray does not have list children!"); } List<? extends ConfigurationNode> children = node.getChildrenList(); generator.beginArray(); for (ConfigurationNode child : children) { generateValue(generator, child); } generator.endArray(); } }
private void generateValue(JsonWriter generator, ConfigurationNode node) throws IOException { if (node.hasMapChildren()) { generateObject(generator, node); } else if (node.hasListChildren()) { generateArray(generator, node); } else if (node.getKey() == null && node.getValue() == null) { generator.beginObject(); generator.endObject(); } else { Object value = node.getValue(); if (value instanceof Double) { generator.value((Double) value); } else if (value instanceof Float) { generator.value((Float) value); } else if (value instanceof Long) { generator.value((Long) value); } else if (value instanceof Integer) { generator.value((Integer) value); } else if (value instanceof Boolean) { generator.value((Boolean) value); } else if (value instanceof byte[]) { //generator.value((byte[]) value); } else { generator.value(value.toString()); } } }
private void generateValue(JsonGenerator generator, ConfigurationNode node) throws IOException { if (node.hasMapChildren()) { generateObject(generator, node); } else if (node.hasListChildren()) { generateArray(generator, node); } else { Object value = node.getValue(); if (value instanceof Double) { generator.writeNumber((Double) value); } else if (value instanceof Float) { generator.writeNumber((Float) value); } else if (value instanceof Long) { generator.writeNumber((Long) value); } else if (value instanceof Integer) { generator.writeNumber((Integer) value); } else if (value instanceof Boolean) { generator.writeBoolean((Boolean) value); } else if (value instanceof byte[]) { generator.writeBinary((byte[]) value); } else { generator.writeString(value.toString()); } } }
private static void generateValue(JsonGenerator generator, ConfigurationNode node) throws IOException { if (node.hasMapChildren()) { generateObject(generator, node); } else if (node.hasListChildren()) { generateArray(generator, node); } else { Object value = node.getValue(); if (value instanceof Double) { generator.writeNumber((Double) value); } else if (value instanceof Float) { generator.writeNumber((Float) value); } else if (value instanceof Long) { generator.writeNumber((Long) value); } else if (value instanceof Integer) { generator.writeNumber((Integer) value); } else if (value instanceof Boolean) { generator.writeBoolean((Boolean) value); } else if (value instanceof byte[]) { generator.writeBinary((byte[]) value); } else { generator.writeString(value.toString()); } } }
void serialize(ConfigurationNode node) throws ObjectMappingException { if (!node.hasListChildren()) { node.setValue(null); } Map<Set<Entry<String, String>>, ConfigurationNode> existingSections = new HashMap<>(); for (ConfigurationNode child : node.getChildrenList()) { existingSections.put(contextsFrom(child), child); } for (Map.Entry<Set<Entry<String, String>>, DataEntry> ent : contexts.entrySet()) { ConfigurationNode contextSection = existingSections.remove(ent.getKey()); if (contextSection == null) { contextSection = node.getAppendedNode(); ConfigurationNode contextsNode = contextSection.getNode(KEY_CONTEXTS); for (Entry<String, String> context : ent.getKey()) { contextsNode.getNode(context.getKey()).setValue(context.getValue()); } } MAPPER.bind(ent.getValue()).serialize(contextSection); } for (ConfigurationNode unused : existingSections.values()) { unused.setValue(null); } }
static FileSubjectData fromNode(ConfigurationNode node) throws ObjectMappingException, PermissionsLoadingException { ImmutableMap.Builder<Set<Entry<String, String>>, DataEntry> map = ImmutableMap.builder(); if (node.hasListChildren()) { for (ConfigurationNode child : node.getChildrenList()) { if (!child.hasMapChildren()) { throw new PermissionsLoadingException(t("Each context section must be of map type! Check that no duplicate nesting has occurred.")); } Set<Entry<String, String>> contexts = contextsFrom(child); DataEntry value = MAPPER.bindToNew().populate(child); map.put(contexts, value); } } return new FileSubjectData(map.build()); }
@Override public Set<?> deserialize(TypeToken<?> type, ConfigurationNode value) throws ObjectMappingException { TypeToken<?> entryType = type.resolveType(Set.class.getTypeParameters()[0]); TypeSerializer<?> entrySerial = value.getOptions().getSerializers().get(entryType); if (entrySerial == null) { throw new ObjectMappingException("No applicable type serializer for type " + entryType); } if (value.hasListChildren()) { List<? extends ConfigurationNode> values = value.getChildrenList(); Set<Object> ret = new HashSet<>(values.size()); for (ConfigurationNode ent : values) { ret.add(entrySerial.deserialize(entryType, ent)); } return ret; } else { Object unwrappedVal = value.getValue(); if (unwrappedVal != null) { return Sets.newHashSet(entrySerial.deserialize(entryType, value)); } } return new HashSet<>(); }
private ConfigValue fromValue(ConfigurationNode node) { ConfigValue ret; if (node.hasMapChildren()) { Map<String, ConfigValue> children = node.getOptions().getMapFactory().create(); for (Map.Entry<Object, ? extends ConfigurationNode> ent : node.getChildrenMap().entrySet()) { children.put(String.valueOf(ent.getKey()), fromValue(ent.getValue())); } ret = newConfigObject(children); } else if (node.hasListChildren()) { List<ConfigValue> children = new ArrayList<>(); for (ConfigurationNode ent : node.getChildrenList()) { children.add(fromValue(ent)); } ret = newConfigList(children); } else { ret = ConfigValueFactory.fromAnyRef(node.getValue(), "configurate-hocon"); } if (node instanceof CommentedConfigurationNode) { CommentedConfigurationNode commentedNode = ((CommentedConfigurationNode) node); final ConfigValue finalRet = ret; ret = commentedNode.getComment().map(comment -> finalRet.withOrigin(finalRet.origin().withComments(LINE_SPLITTER.splitToList(comment)))).orElse(ret); } return ret; }
@Override public List<?> deserialize(TypeToken<?> type, ConfigurationNode value) throws ObjectMappingException { if (!(type.getType() instanceof ParameterizedType)) { throw new ObjectMappingException("Raw types are not supported for collections"); } TypeToken<?> entryType = type.resolveType(List.class.getTypeParameters()[0]); TypeSerializer entrySerial = value.getOptions().getSerializers().get(entryType); if (entrySerial == null) { throw new ObjectMappingException("No applicable type serializer for type " + entryType); } if (value.hasListChildren()) { List<? extends ConfigurationNode> values = value.getChildrenList(); List<Object> ret = new ArrayList<>(values.size()); for (ConfigurationNode ent : values) { ret.add(entrySerial.deserialize(entryType, ent)); } return ret; } else { Object unwrappedVal = value.getValue(); if (unwrappedVal != null) { return Lists.newArrayList(entrySerial.deserialize(entryType, value)); } } return new ArrayList<>(); }
private static ConfigValue fromValue(ConfigurationNode node) { ConfigValue ret; if (node.hasMapChildren()) { Map<String, ConfigValue> children = node.getOptions().getMapFactory().create(); for (Map.Entry<Object, ? extends ConfigurationNode> ent : node.getChildrenMap().entrySet()) { children.put(String.valueOf(ent.getKey()), fromValue(ent.getValue())); } ret = newConfigObject(children); } else if (node.hasListChildren()) { List<ConfigValue> children = new ArrayList<>(); for (ConfigurationNode ent : node.getChildrenList()) { children.add(fromValue(ent)); } ret = newConfigList(children); } else { ret = ConfigValueFactory.fromAnyRef(node.getValue(), "configurate-hocon"); } if (node instanceof CommentedConfigurationNode) { CommentedConfigurationNode commentedNode = ((CommentedConfigurationNode) node); final ConfigValue finalRet = ret; ret = commentedNode.getComment().map(comment -> finalRet.withOrigin(finalRet.origin().withComments(LINE_SPLITTER.splitToList(comment)))).orElse(ret); } return ret; }
@Override public List<?> deserialize(@NonNull TypeToken<?> type, @NonNull ConfigurationNode value) throws ObjectMappingException { if (!(type.getType() instanceof ParameterizedType)) { throw new ObjectMappingException("Raw types are not supported for collections"); } TypeToken<?> entryType = type.resolveType(List.class.getTypeParameters()[0]); TypeSerializer entrySerial = value.getOptions().getSerializers().get(entryType); if (entrySerial == null) { throw new ObjectMappingException("No applicable type serializer for type " + entryType); } if (value.hasListChildren()) { List<? extends ConfigurationNode> values = value.getChildrenList(); List<Object> ret = new ArrayList<>(values.size()); for (ConfigurationNode ent : values) { ret.add(entrySerial.deserialize(entryType, ent)); } return ret; } else { Object unwrappedVal = value.getValue(); if (unwrappedVal != null) { return Lists.newArrayList(entrySerial.deserialize(entryType, value)); } } return new ArrayList<>(); }
@Override public List<?> deserialize(@NonNull TypeToken<?> type, @NonNull ConfigurationNode value) throws ObjectMappingException { if (!(type.getType() instanceof ParameterizedType)) { throw new ObjectMappingException("Raw types are not supported for collections"); } TypeToken<?> entryType = type.resolveType(List.class.getTypeParameters()[0]); TypeSerializer entrySerial = value.getOptions().getSerializers().get(entryType); if (entrySerial == null) { throw new ObjectMappingException("No applicable type serializer for type " + entryType); } if (value.hasListChildren()) { List<? extends ConfigurationNode> values = value.getChildrenList(); List<Object> ret = new ArrayList<>(values.size()); for (ConfigurationNode ent : values) { ret.add(entrySerial.deserialize(entryType, ent)); } return ret; } else { Object unwrappedVal = value.getValue(); if (unwrappedVal != null) { return Lists.newArrayList(entrySerial.deserialize(entryType, value)); } } return new ArrayList<>(); }
@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()); }
@Test public void testUnattachedNodesTemporary() { ConfigurationNode config = SimpleConfigurationNode.root(); ConfigurationNode node = config.getNode("some", "node"); assertTrue(node.isVirtual()); assertNull(node.getValue()); assertFalse(node.hasListChildren()); assertFalse(node.hasMapChildren()); ConfigurationNode node2 = config.getNode("some", "node"); assertNotSame(node, node2); ConfigurationNode node3 = config.getNode("some").getNode("node"); assertNotSame(node, node3); }