import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
final class IdentityrefXmlCodec implements XmlCodec<QName> {
private final @NonNull EffectiveModelContext context;
- private final @NonNull PreferredPrefixes pref;
private final @NonNull QNameModule parentModule;
+ private final @Nullable PreferredPrefixes pref;
- IdentityrefXmlCodec(final EffectiveModelContext context, final PreferredPrefixes pref,
- final QNameModule parentModule) {
+ IdentityrefXmlCodec(final EffectiveModelContext context, final QNameModule parentModule,
+ final @Nullable PreferredPrefixes pref) {
this.context = requireNonNull(context);
- this.pref = requireNonNull(pref);
this.parentModule = requireNonNull(parentModule);
+ this.pref = pref;
}
@Override
@Override
public void writeValue(final XMLStreamWriter ctx, final QName value) throws XMLStreamException {
- final var prefixes = new NamespacePrefixes(pref, ctx.getNamespaceContext());
+ final var prefixes = new NamespacePrefixes(ctx.getNamespaceContext(), pref);
final var str = QNameCodecUtil.encodeQName(value, uri -> prefixes.encodePrefix(uri.getNamespace()));
- for (var e : prefixes.emittedPrefixes()) {
- ctx.writeNamespace(e.getValue(), e.getKey().toString());
+ for (var entry : prefixes.emittedPrefixes()) {
+ ctx.writeNamespace(entry.getValue(), entry.getKey().toString());
}
ctx.writeCharacters(str);
}
import java.util.List;
import java.util.Map.Entry;
import javax.xml.namespace.NamespaceContext;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.Module;
final class InstanceIdentifierSerializer extends AbstractInstanceIdentifierCodec {
private final NamespacePrefixes prefixes;
- InstanceIdentifierSerializer(final DataSchemaContextTree dataContextTree, final PreferredPrefixes pref,
- final NamespaceContext nsContext) {
+ InstanceIdentifierSerializer(final DataSchemaContextTree dataContextTree, final NamespaceContext nsContext,
+ final @Nullable PreferredPrefixes pref) {
super(dataContextTree);
- prefixes = new NamespacePrefixes(pref, nsContext);
+ prefixes = new NamespacePrefixes(nsContext, pref);
}
List<Entry<XMLNamespace, String>> emittedPrefixes() {
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
final class InstanceIdentifierXmlCodec implements XmlCodec<YangInstanceIdentifier> {
private final @NonNull XmlCodecFactory codecFactory;
- private final DataSchemaContextTree dataContextTree;
- private final PreferredPrefixes pref;
+ private final @NonNull DataSchemaContextTree dataContextTree;
+ private final @Nullable PreferredPrefixes pref;
- InstanceIdentifierXmlCodec(final XmlCodecFactory codecFactory, final PreferredPrefixes pref) {
+ InstanceIdentifierXmlCodec(final XmlCodecFactory codecFactory, final @Nullable PreferredPrefixes pref) {
this.codecFactory = requireNonNull(codecFactory);
- this.pref = requireNonNull(pref);
+ this.pref = pref;
dataContextTree = DataSchemaContextTree.from(codecFactory.getEffectiveModelContext());
}
@Override
public void writeValue(final XMLStreamWriter ctx, final YangInstanceIdentifier value) throws XMLStreamException {
- final var serializer = new InstanceIdentifierSerializer(dataContextTree, pref, ctx.getNamespaceContext());
+ final var serializer = new InstanceIdentifierSerializer(dataContextTree, ctx.getNamespaceContext(), pref);
final String str;
try {
*/
package org.opendaylight.yangtools.yang.data.codec.xml;
-import static java.util.Objects.requireNonNull;
-
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
import javax.xml.XMLConstants;
import javax.xml.namespace.NamespaceContext;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.concepts.Mutable;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
private final PreferredPrefixes pref;
private final NamespaceContext context;
- NamespacePrefixes(final PreferredPrefixes pref, final NamespaceContext context) {
- this.pref = requireNonNull(pref);
+ NamespacePrefixes(final NamespaceContext context, final @Nullable PreferredPrefixes pref) {
this.context = context;
+ this.pref = pref;
}
List<Entry<XMLNamespace, String>> emittedPrefixes() {
}
}
- prefix = pref.prefixForNamespace(namespace);
- if (prefix == null) {
- prefix = encode(counter++);
- }
+ prefix = createPrefix(namespace);
+ emittedPrefixes.put(namespace, prefix);
+ return prefix;
+ }
- while (alreadyUsedPrefix(prefix)) {
- prefix = encode(counter++);
+ private @NonNull String createPrefix(final @NonNull XMLNamespace namespace) {
+ if (pref != null) {
+ final var prefix = pref.prefixForNamespace(namespace);
+ if (prefix != null) {
+ return prefix;
+ }
}
- emittedPrefixes.put(namespace, prefix);
+ String prefix;
+ do {
+ prefix = encode(counter++);
+ } while (alreadyUsedPrefix(prefix));
return prefix;
}
private boolean alreadyUsedPrefix(final String prefix) {
+ if (pref != null && pref.isUsed(prefix)) {
+ return true;
+ }
if (context == null) {
return false;
}
import static java.util.Objects.requireNonNull;
import com.google.common.base.MoreObjects;
+import com.google.common.collect.ImmutableBiMap;
import com.google.common.collect.Maps;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
+import java.util.stream.Stream;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
+import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
/**
* Prefixes preferred by an {@link EffectiveModelContext}. This acts as an advisory to {@link NamespacePrefixes} for
* with those ambiguities.
*/
abstract sealed class PreferredPrefixes {
- private static final class Precomputed extends PreferredPrefixes {
- static final @NonNull Precomputed EMPTY = new Precomputed(Map.of());
-
- private final Map<XMLNamespace, String> mappings;
+ static final class Precomputed extends PreferredPrefixes {
+ private final ImmutableBiMap<XMLNamespace, String> mappings;
Precomputed(final Map<XMLNamespace, String> mappings) {
- this.mappings = requireNonNull(mappings);
+ this.mappings = ImmutableBiMap.copyOf(mappings);
}
@Override
return mappings.get(namespace);
}
+ @Override
+ boolean isUsed(final String prefix) {
+ return mappings.inverse().containsKey(prefix);
+ }
+
@Override
Map<XMLNamespace, ?> mappings() {
return mappings;
return modules.hasNext() ? loadPrefix(namespace, modules.next().prefix().argument()) : null;
}
+ @Override
+ boolean isUsed(final String prefix) {
+ return modulesForPrefix(prefix).findAny().isPresent();
+ }
+
/**
* Completely populate known mappings and return an optimized version equivalent of this object.
*
for (var module : modelContext.getModuleStatements().values()) {
prefixForNamespace(module.namespace().argument());
}
- return new Precomputed(Map.copyOf(
- Maps.transformValues(Maps.filterValues(mappings, Optional::isPresent), Optional::orElseThrow)));
+ return new Precomputed(
+ Maps.transformValues(Maps.filterValues(mappings, Optional::isPresent), Optional::orElseThrow));
}
@Override
// Validate that all modules which have the same prefix have also the name namespace
private boolean isValidMapping(final XMLNamespace namespace, final String prefix) {
- if (startsWithXml(prefix)) {
- return false;
- }
- for (var module : modelContext.getModuleStatements().values()) {
- if (prefix.equals(module.prefix().argument()) && !namespace.equals(module.namespace().argument())) {
- return false;
- }
- }
- return true;
+ return !startsWithXml(prefix) && modulesForPrefix(prefix)
+ .allMatch(module -> namespace.equals(module.namespace().argument()));
+ }
+
+ private Stream<ModuleEffectiveStatement> modulesForPrefix(final String prefix) {
+ return modelContext.getModuleStatements().values().stream()
+ .filter(module -> prefix.equals(module.prefix().argument()));
}
// https://www.w3.org/TR/xml-names/#xmlReserved
// Hidden on purpose
}
- static @NonNull PreferredPrefixes empty() {
- return Precomputed.EMPTY;
- }
-
abstract @Nullable String prefixForNamespace(@NonNull XMLNamespace namespace);
+ abstract boolean isUsed(String prefix);
+
@Override
public final String toString() {
return MoreObjects.toStringHelper(this).add("mappings", mappings()).toString();
}
abstract Map<XMLNamespace, ?> mappings();
+
}
import javax.xml.stream.XMLStreamWriter;
import javax.xml.transform.dom.DOMSource;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.rfc7952.model.api.AnnotationSchemaNode;
import org.opendaylight.yangtools.yang.common.AnnotationName;
import org.opendaylight.yangtools.yang.common.QName;
private final NormalizedNodeStreamWriterStack tracker;
private final SchemaAwareXMLStreamWriterUtils streamUtils;
- private SchemaAwareXMLStreamNormalizedNodeStreamWriter(final PreferredPrefixes pref, final XMLStreamWriter writer,
- final EffectiveModelContext modelContext, final NormalizedNodeStreamWriterStack tracker) {
- super(pref, writer);
+ private SchemaAwareXMLStreamNormalizedNodeStreamWriter(final XMLStreamWriter writer,
+ final EffectiveModelContext modelContext, final NormalizedNodeStreamWriterStack tracker,
+ final @Nullable PreferredPrefixes pref) {
+ super(writer, pref);
this.tracker = requireNonNull(tracker);
streamUtils = new SchemaAwareXMLStreamWriterUtils(modelContext, pref);
}
SchemaAwareXMLStreamNormalizedNodeStreamWriter(final XMLStreamWriter writer,
- final EffectiveModelContext modelContext, final NormalizedNodeStreamWriterStack tracker) {
- this(new PreferredPrefixes.Shared(modelContext), writer, modelContext, tracker);
+ final EffectiveModelContext modelContext, final NormalizedNodeStreamWriterStack tracker,
+ final boolean modelPrefixes) {
+ this(writer, modelContext, tracker, modelPrefixes ? new PreferredPrefixes.Shared(modelContext) : null);
}
@Override
import javax.xml.stream.XMLStreamException;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
final class SchemaAwareXMLStreamWriterUtils extends XMLStreamWriterUtils {
private final @NonNull EffectiveModelContext modelContext;
- private final @NonNull PreferredPrefixes pref;
+ private final @Nullable PreferredPrefixes pref;
- SchemaAwareXMLStreamWriterUtils(final EffectiveModelContext modelContext, final PreferredPrefixes pref) {
+ SchemaAwareXMLStreamWriterUtils(final EffectiveModelContext modelContext, final @Nullable PreferredPrefixes pref) {
this.modelContext = requireNonNull(modelContext);
- this.pref = requireNonNull(pref);
+ this.pref = pref;
}
@NonNull EffectiveModelContext modelContext() {
@Override
String encodeInstanceIdentifier(final ValueWriter writer, final YangInstanceIdentifier value)
throws XMLStreamException {
- final var serializer = new InstanceIdentifierSerializer(DataSchemaContextTree.from(modelContext), pref,
- writer.getNamespaceContext());
+ final var serializer = new InstanceIdentifierSerializer(DataSchemaContextTree.from(modelContext),
+ writer.getNamespaceContext(), pref);
final var str = serializer.serialize(value);
for (var entry : serializer.emittedPrefixes()) {
writer.writeNamespace(entry.getValue(), entry.getKey().toString());
private final Deque<NodeType> nodeTypeStack = new ArrayDeque<>();
SchemalessXMLStreamNormalizedNodeStreamWriter(final XMLStreamWriter writer) {
- super(PreferredPrefixes.empty(), writer);
+ super(writer, null);
}
@Override
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.XMLStreamWriter;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedAnydata;
// namespace declarations or value.
private QName openElement;
- StreamWriterFacade(final PreferredPrefixes pref, final XMLStreamWriter writer) {
+ StreamWriterFacade(final XMLStreamWriter writer, final @Nullable PreferredPrefixes pref) {
this.writer = requireNonNull(writer);
- prefixes = new NamespacePrefixes(pref, writer.getNamespaceContext());
+ prefixes = new NamespacePrefixes(writer.getNamespaceContext(), pref);
}
void writeCharacters(final String text) throws XMLStreamException {
private final @NonNull StreamWriterFacade facade;
- XMLStreamNormalizedNodeStreamWriter(final PreferredPrefixes pref, final XMLStreamWriter writer) {
- facade = new StreamWriterFacade(pref, writer);
+ XMLStreamNormalizedNodeStreamWriter(final XMLStreamWriter writer, final @Nullable PreferredPrefixes pref) {
+ facade = new StreamWriterFacade(writer, pref);
}
/**
*/
public static @NonNull NormalizedNodeStreamWriter create(final XMLStreamWriter writer,
final EffectiveModelContext context) {
+ return create(writer, context, false);
+ }
+
+ /**
+ * Create a new writer with the specified context as its root.
+ *
+ * @param writer Output {@link XMLStreamWriter}
+ * @param context Associated {@link EffectiveModelContext}.
+ * @param preferPrefixes prefer prefixes known to {@code context}
+ * @return A new {@link NormalizedNodeStreamWriter}
+ */
+ public static @NonNull NormalizedNodeStreamWriter create(final XMLStreamWriter writer,
+ final EffectiveModelContext context, final boolean preferPrefixes) {
return new SchemaAwareXMLStreamNormalizedNodeStreamWriter(writer, context,
- NormalizedNodeStreamWriterStack.of(context));
+ NormalizedNodeStreamWriterStack.of(context), preferPrefixes);
}
/**
*/
public static @NonNull NormalizedNodeStreamWriter create(final XMLStreamWriter writer,
final EffectiveStatementInference inference) {
+ return create(writer, inference, false);
+ }
+
+ /**
+ * Create a new writer with the specified context and rooted at the specified node.
+ *
+ * @param writer Output {@link XMLStreamWriter}
+ * @param inference root node inference
+ * @param preferPrefixes prefer prefixes known to {@code context}
+ * @return A new {@link NormalizedNodeStreamWriter}
+ */
+ public static @NonNull NormalizedNodeStreamWriter create(final XMLStreamWriter writer,
+ final EffectiveStatementInference inference, final boolean preferPrefixes) {
return new SchemaAwareXMLStreamNormalizedNodeStreamWriter(writer, inference.getEffectiveModelContext(),
- NormalizedNodeStreamWriterStack.of(inference));
+ NormalizedNodeStreamWriterStack.of(inference), preferPrefixes);
}
/**
*/
public static @NonNull NormalizedNodeStreamWriter create(final XMLStreamWriter writer,
final EffectiveModelContext context, final @Nullable Absolute path) {
+ return create(writer, context, path, false);
+ }
+
+ /**
+ * Create a new writer with the specified context and rooted in the specified schema path.
+ *
+ * @param writer Output {@link XMLStreamWriter}
+ * @param context Associated {@link EffectiveModelContext}.
+ * @param path path
+ * @param preferPrefixes prefer prefixes known to {@code context}
+ * @return A new {@link NormalizedNodeStreamWriter}
+ */
+ public static @NonNull NormalizedNodeStreamWriter create(final XMLStreamWriter writer,
+ final EffectiveModelContext context, final @Nullable Absolute path, final boolean preferPrefixes) {
return path == null ? create(writer, context)
: new SchemaAwareXMLStreamNormalizedNodeStreamWriter(writer, context,
- NormalizedNodeStreamWriterStack.of(context, path));
+ NormalizedNodeStreamWriterStack.of(context, path), preferPrefixes);
}
/**
*/
public static @NonNull NormalizedNodeStreamWriter create(final XMLStreamWriter writer,
final EffectiveModelContext context, final YangInstanceIdentifier path) {
+ return create(writer, context, path, false);
+ }
+
+ /**
+ * Create a new writer with the specified context and rooted in the specified {@link YangInstanceIdentifier}.
+ *
+ * @param writer Output {@link XMLStreamWriter}
+ * @param context Associated {@link EffectiveModelContext}.
+ * @param path path
+ * @param preferPrefixes prefer prefixes known to {@code context}
+ * @return A new {@link NormalizedNodeStreamWriter}
+ */
+ public static @NonNull NormalizedNodeStreamWriter create(final XMLStreamWriter writer,
+ final EffectiveModelContext context, final YangInstanceIdentifier path, final boolean preferPrefixes) {
return new SchemaAwareXMLStreamNormalizedNodeStreamWriter(writer, context,
- NormalizedNodeStreamWriterStack.of(context, path));
+ NormalizedNodeStreamWriterStack.of(context, path), preferPrefixes);
}
/**
*/
public static @NonNull NormalizedNodeStreamWriter forInputOf(final XMLStreamWriter writer,
final EffectiveModelContext context, final Absolute operationPath) {
+ return forInputOf(writer, context, operationPath, false);
+ }
+
+ /**
+ * Create a new writer with the specified context and rooted in the specified operation's input.
+ *
+ * @param writer Output {@link XMLStreamWriter}
+ * @param context Associated {@link EffectiveModelContext}.
+ * @param operationPath Parent operation (RPC or action) path.
+ * @param preferPrefixes prefer prefixes known to {@code context}
+ * @return A new {@link NormalizedNodeStreamWriter}
+ */
+ public static @NonNull NormalizedNodeStreamWriter forInputOf(final XMLStreamWriter writer,
+ final EffectiveModelContext context, final Absolute operationPath, final boolean preferPrefixes) {
return forOperation(writer, context, operationPath,
- YangConstants.operationInputQName(operationPath.lastNodeIdentifier().getModule()));
+ YangConstants.operationInputQName(operationPath.lastNodeIdentifier().getModule()), preferPrefixes);
}
/**
*/
public static @NonNull NormalizedNodeStreamWriter forOutputOf(final XMLStreamWriter writer,
final EffectiveModelContext context, final Absolute operationPath) {
+ return forOutputOf(writer, context, operationPath, false);
+ }
+
+ /**
+ * Create a new writer with the specified context and rooted in the specified operation's output.
+ *
+ * @param writer Output {@link XMLStreamWriter}
+ * @param context Associated {@link EffectiveModelContext}.
+ * @param operationPath Parent operation (RPC or action) path.
+ * @param preferPrefixes prefer prefixes known to {@code context}
+ * @return A new {@link NormalizedNodeStreamWriter}
+ */
+ public static @NonNull NormalizedNodeStreamWriter forOutputOf(final XMLStreamWriter writer,
+ final EffectiveModelContext context, final Absolute operationPath, final boolean preferPrefixes) {
return forOperation(writer, context, operationPath,
- YangConstants.operationOutputQName(operationPath.lastNodeIdentifier().getModule()));
+ YangConstants.operationOutputQName(operationPath.lastNodeIdentifier().getModule()),
+ preferPrefixes);
}
private static @NonNull NormalizedNodeStreamWriter forOperation(final XMLStreamWriter writer,
- final EffectiveModelContext context, final Absolute operationPath, final QName qname) {
+ final EffectiveModelContext context, final Absolute operationPath, final QName qname,
+ final boolean preferPrefixes) {
return new SchemaAwareXMLStreamNormalizedNodeStreamWriter(writer, context,
- NormalizedNodeStreamWriterStack.ofOperation(context, operationPath, qname));
+ NormalizedNodeStreamWriterStack.ofOperation(context, operationPath, qname), preferPrefixes);
}
/**
import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.MountPointContext;
* A thread-safe factory for instantiating {@link XmlCodec}s.
*/
public final class XmlCodecFactory extends AbstractCodecFactory<XmlCodec<?>> {
- private final @NonNull MountPointContext mountCtx;
- private final @NonNull PreferredPrefixes pref;
private final @NonNull InstanceIdentifierXmlCodec instanceIdentifierCodec;
+ private final @NonNull MountPointContext mountCtx;
+ private final @Nullable PreferredPrefixes pref;
- private XmlCodecFactory(final MountPointContext mountCtx) {
+ private XmlCodecFactory(final MountPointContext mountCtx, final boolean modelPrefixes) {
super(mountCtx.getEffectiveModelContext(), new SharedCodecCache<>());
this.mountCtx = requireNonNull(mountCtx);
- pref = new PreferredPrefixes.Shared(getEffectiveModelContext());
+ pref = modelPrefixes ? new PreferredPrefixes.Shared(getEffectiveModelContext()) : null;
instanceIdentifierCodec = new InstanceIdentifierXmlCodec(this, pref);
}
* @return A codec factory instance.
*/
public static XmlCodecFactory create(final MountPointContext context) {
- return new XmlCodecFactory(context);
+ return create(context, false);
+ }
+
+ /**
+ * Instantiate a new codec factory attached to a particular context.
+ *
+ * @param context MountPointContext to which the factory should be bound
+ * @param preferPrefixes prefer prefixes known to {@code context}
+ * @return A codec factory instance.
+ */
+ public static XmlCodecFactory create(final MountPointContext context, final boolean preferPrefixes) {
+ return new XmlCodecFactory(context, preferPrefixes);
}
/**
* @return A codec factory instance.
*/
public static XmlCodecFactory create(final EffectiveModelContext context) {
- return create(MountPointContext.of(context));
+ return create(context, false);
+ }
+
+ /**
+ * Instantiate a new codec factory attached to a particular context.
+ *
+ * @param context SchemaContext to which the factory should be bound
+ * @param preferPrefixes prefer prefixes known to {@code context}
+ * @return A codec factory instance.
+ */
+ public static XmlCodecFactory create(final EffectiveModelContext context, final boolean preferPrefixes) {
+ return create(MountPointContext.of(requireNonNull(context)), preferPrefixes);
}
@Override
@Override
protected XmlCodec<?> identityRefCodec(final IdentityrefTypeDefinition type, final QNameModule module) {
- return new IdentityrefXmlCodec(getEffectiveModelContext(), pref, module);
+ return new IdentityrefXmlCodec(getEffectiveModelContext(), module, pref);
}
@Override
@Test
void testQNameWithPrefix() {
- final var a = new NamespacePrefixes(PreferredPrefixes.empty(), null);
+ final var a = new NamespacePrefixes(null, null);
final var allGenerated = new ArrayList<String>();
for (int i = 0; i < MAX_COUNTER; i++) {
@Test
void test2QNames1Namespace() {
- final var a = new NamespacePrefixes(PreferredPrefixes.empty(), null);
+ final var a = new NamespacePrefixes(null, null);
final var uri = XMLNamespace.of("localhost");
@Test
void testQNameNoPrefix() {
- final var a = new NamespacePrefixes(PreferredPrefixes.empty(), null);
+ final var a = new NamespacePrefixes(null, new PreferredPrefixes.Precomputed(Map.of()));
final var uri = XMLNamespace.of("localhost");
final var second = XMLNamespace.of("second");
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Map;
import java.util.Optional;
final var prefixes = new PreferredPrefixes.Shared(context);
assertEquals("f", prefixes.prefixForNamespace(FOONS));
assertEquals("Shared{mappings={foons=Optional[f]}}", prefixes.toString());
- assertEquals("Precomputed{mappings={foons=f}}", prefixes.toPrecomputed().toString());
+
+ final var precomputed = prefixes.toPrecomputed();
+ assertEquals("f", precomputed.prefixForNamespace(FOONS));
+ assertEquals("Precomputed{mappings={foons=f}}", precomputed.toString());
}
@Test
XMLNamespace.of("quxns"), "xmx",
XMLNamespace.of("xyzzyns"), "xyz"), new PreferredPrefixes.Shared(context).toPrecomputed().mappings());
}
+
+ @Test
+ void ignorePrefixesStartingWithXML() {
+ final var prefixes = new PreferredPrefixes.Shared(YangParserTestUtils.parseYang("""
+ module foo {
+ namespace foons;
+ prefix a;
+ }"""));
+ assertTrue(prefixes.isUsed("a"));
+ assertEquals("Shared{mappings={}}", prefixes.toString());
+ final var precomputed = prefixes.toPrecomputed();
+ assertTrue(precomputed.isUsed("a"));
+ assertEquals("Precomputed{mappings={foons=a}}", precomputed.toString());
+ }
}
String xmlAsString = createXml(writer -> {
writer.writeStartElement("element");
- final var facade = new StreamWriterFacade(pref, writer);
+ final var facade = new StreamWriterFacade(writer, pref);
facade.writeCharacters(XMLStreamWriterUtils.encode(facade, QName.create(parent, "identity"), parent));
facade.flush();
writer.writeEndElement();
xmlAsString = createXml(writer -> {
writer.writeStartElement("elementDifferent");
- final var facade = new StreamWriterFacade(pref, writer);
+ final var facade = new StreamWriterFacade(writer, pref);
facade.writeCharacters(XMLStreamWriterUtils.encode(facade, QName.create("different:namespace", "identity"),
parent));
facade.flush();
final var baz = assertInstanceOf(ListSchemaNode.class, modelContext.getDataChildByName(FOO_BAZ));
final var id = assertInstanceOf(LeafSchemaNode.class, baz.getDataChildByName(FOO_ID));
final var type = assertInstanceOf(InstanceIdentifierTypeDefinition.class, id.getType());
- CODEC = XmlCodecFactory.create(modelContext).instanceIdentifierCodec(type);
+ CODEC = XmlCodecFactory.create(modelContext, true).instanceIdentifierCodec(type);
}
@AfterAll
void nestedInstanceIdentifierInDocument() throws Exception {
final var stringWriter = new StringWriter();
try (var xmlWriter = XMLStreamNormalizedNodeStreamWriter.create(
- TestFactories.DEFAULT_OUTPUT_FACTORY.createXMLStreamWriter(stringWriter), MODEL_CONTEXT)) {
+ TestFactories.DEFAULT_OUTPUT_FACTORY.createXMLStreamWriter(stringWriter), MODEL_CONTEXT, true)) {
try (var nnWriter = NormalizedNodeWriter.forStreamWriter(xmlWriter)) {
// Contrived: we have a document for foo's 'foo' container, with 'leaf' pointing to an instance of bar's
// 'bar' list item, whose key points to baz's 'baz' container.
xmlWriter.writeStartElement(XMLConstants.DEFAULT_NS_PREFIX, "foo", "foons");
xmlWriter.writeDefaultNamespace("foons");
xmlWriter.writeStartElement("leaf");
- XmlCodecFactory.create(MODEL_CONTEXT).instanceIdentifierCodec().writeValue(xmlWriter, IID);
+ XmlCodecFactory.create(MODEL_CONTEXT, true).instanceIdentifierCodec().writeValue(xmlWriter, IID);
xmlWriter.writeEndElement();
xmlWriter.writeEndElement();
xmlWriter.close();
Code Review / yangtools.git / commitdiff