@SuppressWarnings("rawtypes") private static void emitAugmentation(final Class type, final Augmentation<?> value, final BindingStreamEventWriter stream, final DataObjectSerializerRegistry registry) throws IOException { /* * Binding Specification allowed to insert augmentation with null for * value, which effectively could be used to remove augmentation * from builder / DTO. */ if (value == null) { return; } Preconditions.checkArgument(value instanceof DataObject); @SuppressWarnings("unchecked") final DataObjectSerializer serializer = registry.getSerializer(type); if (serializer != null) { serializer.serialize((DataObject) value, stream); } else { LOG.warn("DataObjectSerializer is not present for {} in registry {}", type, registry); } } }
@Override public void writeAsNormalizedNode(final D data, final NormalizedNodeStreamWriter writer) { try { eventStreamSerializer().serialize(data, createWriter(writer)); } catch (final IOException e) { throw new IllegalStateException("Failed to serialize Binding DTO",e); } } }
@Override @SuppressWarnings("unchecked") public void serialize(final DataObjectSerializerRegistry reg, final DataObject obj, final BindingStreamEventWriter stream) throws IOException { @SuppressWarnings("rawtypes") Class cazeClass = obj.getImplementedInterface(); stream.startChoiceNode(choiceClass, BindingStreamEventWriter.UNKNOWN_SIZE); DataObjectSerializer caseSerializer = reg.getSerializer(cazeClass); if (caseSerializer != null) { caseSerializer.serialize(obj, stream); } else { LOG.warn("No serializer for case {} is available in registry {}", cazeClass, reg); } stream.endNode(); } }
private <T extends DataContainer> ContainerNode serializeDataObject(final DataObject data, final BiFunction<Class<? extends T>, NormalizedNodeStreamWriter, BindingStreamEventWriter> newWriter) { final NormalizedNodeResult result = new NormalizedNodeResult(); // We create DOM stream writer which produces normalized nodes final NormalizedNodeStreamWriter domWriter = ImmutableNormalizedNodeStreamWriter.from(result); @SuppressWarnings("unchecked") final Class<? extends DataObject> type = (Class<? extends DataObject>) data.getImplementedInterface(); final BindingStreamEventWriter writer = newWriter.apply((Class<T>)type, domWriter); try { getSerializer(type).serialize(data, writer); } catch (final IOException e) { LOG.error("Unexpected failure while serializing data {}", data, e); throw new IllegalStateException("Failed to create normalized node", e); } return (ContainerNode) result.getResult(); }
@Override public <T extends DataObject> Entry<YangInstanceIdentifier, NormalizedNode<?,?>> toNormalizedNode( final InstanceIdentifier<T> path, final T data) { final NormalizedNodeResult result = new NormalizedNodeResult(); // We create DOM stream writer which produces normalized nodes final NormalizedNodeStreamWriter domWriter = ImmutableNormalizedNodeStreamWriter.from(result); // We create Binding Stream Writer which translates from Binding to Normalized Nodes final Entry<YangInstanceIdentifier, BindingStreamEventWriter> writeCtx = codecContext.newWriter(path, domWriter); // We get serializer which reads binding data and uses Binding To Normalized Node writer to write result try { getSerializer(path.getTargetType()).serialize(data, writeCtx.getValue()); } catch (final IOException e) { LOG.error("Unexpected failure while serializing path {} data {}", path, data, e); throw new IllegalStateException("Failed to create normalized node", e); } return new SimpleEntry<>(writeCtx.getKey(),result.getResult()); }
/** * Serializes supplied data using stream writer with child cache enabled. * * @param cacheHolder Binding to Normalized Node Cache holder * @param subtreeRoot Codec Node for provided data object * @param data Data to be serialized * @return Normalized Node representation of data. */ static NormalizedNode<?, ?> serializeUsingStreamWriter(final AbstractBindingNormalizedNodeCacheHolder cacheHolder, final DataContainerCodecContext<?, ?> subtreeRoot, final DataObject data) { final CachingNormalizedNodeSerializer writer = new CachingNormalizedNodeSerializer(cacheHolder, subtreeRoot); try { subtreeRoot.eventStreamSerializer().serialize(data, writer); return writer.build(); } catch (final IOException e) { throw new RuntimeException(e); } } }
codecRegistry.getSerializer(path.getTargetType()).serialize(object, bindingWriter); } catch (final IOException e) { throw new IllegalStateException(e);