X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=test-common%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Ftransportpce%2Ftest%2Fconverter%2FXMLDataObjectConverter.java;h=653efb160ad0cdbf12b486fd42d671b9e8c75fe0;hb=refs%2Fchanges%2F29%2F106829%2F13;hp=fefafd1819ceab6779ef48174cb411e2b32690d8;hpb=6fede53990d78fad5c5a52d184245aa5db43fe5f;p=transportpce.git diff --git a/test-common/src/main/java/org/opendaylight/transportpce/test/converter/XMLDataObjectConverter.java b/test-common/src/main/java/org/opendaylight/transportpce/test/converter/XMLDataObjectConverter.java index fefafd181..653efb160 100644 --- a/test-common/src/main/java/org/opendaylight/transportpce/test/converter/XMLDataObjectConverter.java +++ b/test-common/src/main/java/org/opendaylight/transportpce/test/converter/XMLDataObjectConverter.java @@ -12,9 +12,7 @@ import java.io.InputStream; import java.io.Reader; import java.io.StringWriter; import java.io.Writer; -import java.net.URISyntaxException; import java.util.Optional; -import javax.annotation.Nonnull; import javax.xml.XMLConstants; import javax.xml.parsers.FactoryConfigurationError; import javax.xml.stream.XMLInputFactory; @@ -22,26 +20,26 @@ import javax.xml.stream.XMLOutputFactory; import javax.xml.stream.XMLStreamException; import javax.xml.stream.XMLStreamReader; import javax.xml.stream.XMLStreamWriter; +import org.eclipse.jdt.annotation.NonNull; import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer; import org.opendaylight.transportpce.test.DataStoreContext; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.common.QName; -import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter; import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeWriter; import org.opendaylight.yangtools.yang.data.codec.xml.XMLStreamNormalizedNodeStreamWriter; -import org.opendaylight.yangtools.yang.data.codec.xml.XmlCodecFactory; import org.opendaylight.yangtools.yang.data.codec.xml.XmlParserStream; import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter; -import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult; +import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder; import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext; +import org.opendaylight.yangtools.yang.model.api.EffectiveStatementInference; import org.opendaylight.yangtools.yang.model.api.SchemaNode; -import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack; +import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import org.xml.sax.SAXException; public final class XMLDataObjectConverter extends AbstractDataObjectConverter { @@ -70,7 +68,7 @@ public final class XMLDataObjectConverter extends AbstractDataObjectConverter { * @param dataStoreContextUtil datastore context util used to extract codec and schema context * @return {@link AbstractDataObjectConverter} */ - public static XMLDataObjectConverter createWithDataStoreUtil(@Nonnull DataStoreContext dataStoreContextUtil) { + public static XMLDataObjectConverter createWithDataStoreUtil(@NonNull DataStoreContext dataStoreContextUtil) { BindingNormalizedNodeSerializer bindingToNormalizedNodeCodec = dataStoreContextUtil.getBindingDOMCodecServices(); return new XMLDataObjectConverter(dataStoreContextUtil.getSchemaContext(), bindingToNormalizedNodeCodec); @@ -83,8 +81,8 @@ public final class XMLDataObjectConverter extends AbstractDataObjectConverter { * @param codecRegistry codec registry used for converting * @return new {@link XMLDataObjectConverter} */ - public static XMLDataObjectConverter createWithSchemaContext(@Nonnull EffectiveModelContext schemaContext, - @Nonnull BindingNormalizedNodeSerializer codecRegistry) { + public static XMLDataObjectConverter createWithSchemaContext(@NonNull EffectiveModelContext schemaContext, + @NonNull BindingNormalizedNodeSerializer codecRegistry) { return new XMLDataObjectConverter(schemaContext, codecRegistry); } @@ -95,8 +93,7 @@ public final class XMLDataObjectConverter extends AbstractDataObjectConverter { * @return {@link Optional} instance of {@link NormalizedNode}. */ @Override - public Optional> transformIntoNormalizedNode( - @Nonnull InputStream inputStream) { + public Optional transformIntoNormalizedNode(@NonNull InputStream inputStream) { try { XMLStreamReader reader = this.xmlInputFactory.createXMLStreamReader(inputStream); return parseInputXML(reader); @@ -106,26 +103,29 @@ public final class XMLDataObjectConverter extends AbstractDataObjectConverter { } } - public Optional> transformIntoNormalizedNode( - @Nonnull Reader inputReader, SchemaNode parentSchema) { + @Override + public Optional transformIntoNormalizedNode(@NonNull Reader inputReader) { try { XMLStreamReader reader = this.xmlInputFactory.createXMLStreamReader(inputReader); - return parseInputXML(reader, parentSchema); + return parseInputXML(reader); } catch (XMLStreamException e) { LOG.warn("XMLStreamException: {}", e.getMessage()); return Optional.empty(); } } + @Override + public Optional transformIntoNormalizedNode(Reader inputReader, SchemaNode parentSchema) { + throw new UnsupportedOperationException("Not Implemented yet"); + } + /** * Transforms the XML input stream into normalized nodes. * * @param inputReader of the given XML * @return {@link Optional} instance of {@link NormalizedNode}. */ - @Override - public Optional> transformIntoNormalizedNode( - @Nonnull Reader inputReader) { + public Optional transformInschemaContexttoNormalizedNode(@NonNull Reader inputReader) { try { XMLStreamReader reader = this.xmlInputFactory.createXMLStreamReader(inputReader); return parseInputXML(reader); @@ -136,20 +136,17 @@ public final class XMLDataObjectConverter extends AbstractDataObjectConverter { } @Override - public Writer writerFromRpcDataObject(@Nonnull DataObject object, Class dataObjectClass, + public Writer writerFromRpcDataObject(@NonNull DataObject object, Class dataObjectClass, ConvertType convertType, QName rpcOutputQName, String rpcName) { Writer writer = new StringWriter(); XMLStreamWriter xmlStreamWriter = createXmlStreamWriter(writer); - SchemaPath rpcOutputSchemaPath = SchemaPath.create(true, QName.create(rpcOutputQName.getModule(), rpcName), - rpcOutputQName); - try (NormalizedNodeWriter normalizedNodeWriter = createWriterBackedNormalizedNodeWriter(xmlStreamWriter, - rpcOutputSchemaPath)) { + try (NormalizedNodeWriter normalizedNodeWriter = createWriterBackedNormalizedNodeWriter(xmlStreamWriter)) { xmlStreamWriter.writeStartElement(XMLConstants.DEFAULT_NS_PREFIX, rpcOutputQName.getLocalName(), rpcOutputQName.getNamespace().toString()); xmlStreamWriter.writeDefaultNamespace(rpcOutputQName.getNamespace().toString()); - NormalizedNode rpcOutputNormalizedNode = convertType.toNormalizedNodes(dataObjectClass.cast(object), - dataObjectClass).get(); - for (final NormalizedNode child : ((ContainerNode)rpcOutputNormalizedNode).getValue()) { + NormalizedNode rpcOutputNormalizedNode = + convertType.toNormalizedNodes(dataObjectClass.cast(object), dataObjectClass).orElseThrow(); + for (final NormalizedNode child : ((ContainerNode)rpcOutputNormalizedNode).body()) { normalizedNodeWriter.write(child); } normalizedNodeWriter.flush(); @@ -170,13 +167,19 @@ public final class XMLDataObjectConverter extends AbstractDataObjectConverter { * */ @Override - public Writer writerFromDataObject(@Nonnull DataObject object, Class dataObjectClass, + public Writer writerFromDataObject(@NonNull DataObject object, Class dataObjectClass, ConvertType convertType) { + Writer writer = new StringWriter(); + Optional normalizedNode = convertType + .toNormalizedNodes(dataObjectClass.cast(object), dataObjectClass); + if (normalizedNode.isEmpty()) { + LOG.warn("enable to convert {} to {}", dataObjectClass, object.getClass()); + return writer; + } - try (NormalizedNodeWriter normalizedNodeWriter = createWriterBackedNormalizedNodeWriter(writer, null)) { - normalizedNodeWriter - .write(convertType.toNormalizedNodes(dataObjectClass.cast(object), dataObjectClass).get()); + try (NormalizedNodeWriter normalizedNodeWriter = createWriterBackedNormalizedNodeWriter(writer)) { + normalizedNodeWriter.write(normalizedNode.orElseThrow()); normalizedNodeWriter.flush(); } catch (IOException ioe) { throw new IllegalStateException(ioe); @@ -184,48 +187,35 @@ public final class XMLDataObjectConverter extends AbstractDataObjectConverter { return writer; } - private Optional> parseInputXML( - XMLStreamReader reader) { + private Optional parseInputXML(XMLStreamReader reader) { return parseInputXML(reader, getSchemaContext()); } - private Optional> parseInputXML( - XMLStreamReader reader, SchemaNode parentSchemaNode) { - NormalizedNodeResult result = new NormalizedNodeResult(); + private Optional parseInputXML(XMLStreamReader reader, SchemaNode parentSchemaNode) { + NormalizationResultHolder result = new NormalizationResultHolder(); + EffectiveStatementInference schema = SchemaInferenceStack.of(getSchemaContext()).toInference(); try (NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result); - XmlParserStream xmlParser = XmlParserStream - .create(streamWriter, XmlCodecFactory.create(getSchemaContext()), parentSchemaNode)) { + XmlParserStream xmlParser = XmlParserStream + .create(streamWriter, schema)) { xmlParser.parse(reader); - } catch (XMLStreamException | URISyntaxException | IOException | SAXException e) { + } catch (XMLStreamException | IOException e) { LOG.warn("An error occured during parsing XML input stream", e); return Optional.empty(); } - return Optional.ofNullable(result.getResult()); + return Optional.ofNullable(result.getResult().data()); } - private NormalizedNodeWriter createWriterBackedNormalizedNodeWriter(Writer backingWriter, SchemaPath pathToParent) { + private NormalizedNodeWriter createWriterBackedNormalizedNodeWriter(Writer backingWriter) { XMLStreamWriter createXMLStreamWriter = createXmlStreamWriter(backingWriter); NormalizedNodeStreamWriter streamWriter; - if (pathToParent == null) { - streamWriter = XMLStreamNormalizedNodeStreamWriter.create(createXMLStreamWriter, - getSchemaContext()); - } else { - streamWriter = XMLStreamNormalizedNodeStreamWriter.create(createXMLStreamWriter, - getSchemaContext(), pathToParent); - } + streamWriter = XMLStreamNormalizedNodeStreamWriter.create(createXMLStreamWriter, getSchemaContext()); return NormalizedNodeWriter.forStreamWriter(streamWriter); } - private NormalizedNodeWriter createWriterBackedNormalizedNodeWriter(XMLStreamWriter backingWriter, - SchemaPath pathToParent) { - NormalizedNodeStreamWriter streamWriter; - if (pathToParent == null) { - streamWriter = XMLStreamNormalizedNodeStreamWriter.create(backingWriter, - getSchemaContext()); - } else { - streamWriter = XMLStreamNormalizedNodeStreamWriter.create(backingWriter, - getSchemaContext(), pathToParent); - } + private NormalizedNodeWriter createWriterBackedNormalizedNodeWriter(XMLStreamWriter backingWriter) { + Inference rootNode = SchemaInferenceStack.of(getSchemaContext()).toInference(); + NormalizedNodeStreamWriter streamWriter = XMLStreamNormalizedNodeStreamWriter + .create(backingWriter, rootNode); return NormalizedNodeWriter.forStreamWriter(streamWriter); }