import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Maps;
-import java.net.URI;
import java.util.Set;
import org.jaxen.Context;
import org.jaxen.Function;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
public class BitIsSetXPathFunctionTest {
private static final JaxenSchemaContextFactory SCHEMA_CONTEXT_FACTORY = new JaxenSchemaContextFactory();
- private static final QNameModule FOO_MODULE = QNameModule.create(URI.create("foo-ns"), Revision.of("2017-04-03"));
+ private static final QNameModule FOO_MODULE =
+ QNameModule.create(XMLNamespace.of("foo-ns"), Revision.of("2017-04-03"));
private static final QName MY_CONTAINER = QName.create(FOO_MODULE, "my-container");
private static final QName MY_LIST = QName.create(FOO_MODULE, "my-list");
private static final QName FLAGS = QName.create(FOO_MODULE, "flags");
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
-import java.net.URI;
import java.util.Map;
import org.jaxen.Function;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
private static JaxenSchemaContextFactory jaxenSchemaContextFactory = new JaxenSchemaContextFactory();
- private static final QNameModule FOO_MODULE = QNameModule.create(URI.create("foo-ns"), Revision.of("2017-04-03"));
+ private static final QNameModule FOO_MODULE =
+ QNameModule.create(XMLNamespace.of("foo-ns"), Revision.of("2017-04-03"));
private static final QName MY_CONTAINER = QName.create(FOO_MODULE, "my-container");
private static final QName MY_INNER_CONTAINER = QName.create(FOO_MODULE, "my-inner-container");
private static final QName MY_LIST = QName.create(FOO_MODULE, "my-list");
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
-import java.net.URI;
import org.jaxen.Context;
import org.jaxen.Function;
import org.jaxen.FunctionCallException;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
public class DerivedFromXPathFunctionTest {
private static final JaxenSchemaContextFactory SCHEMA_CONTEXT_FACTORY = new JaxenSchemaContextFactory();
- private static final QNameModule BAR_MODULE = QNameModule.create(URI.create("bar-ns"), Revision.of("2017-04-03"));
+ private static final QNameModule BAR_MODULE =
+ QNameModule.create(XMLNamespace.of("bar-ns"), Revision.of("2017-04-03"));
private static final QName MY_CONTAINER = QName.create(BAR_MODULE, "my-container");
private static final QName MY_LIST = QName.create(BAR_MODULE, "my-list");
private static final QName KEY_LEAF = QName.create(BAR_MODULE, "key-leaf");
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
-import java.net.URI;
import org.jaxen.Context;
import org.jaxen.Function;
import org.jaxen.FunctionCallException;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
public class EnumValueXPathFunctionTest {
private static final JaxenSchemaContextFactory SCHEMA_CONTEXT_FACTORY = new JaxenSchemaContextFactory();
- private static final QNameModule FOO_MODULE = QNameModule.create(URI.create("foo-ns"), Revision.of("2017-04-03"));
+ private static final QNameModule FOO_MODULE =
+ QNameModule.create(XMLNamespace.of("foo-ns"), Revision.of("2017-04-03"));
private static final QName MY_CONTAINER = QName.create(FOO_MODULE, "my-container");
private static final QName ALARM = QName.create(FOO_MODULE, "alarm");
private static final QName SEVERITY = QName.create(FOO_MODULE, "severity");
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
import com.google.common.collect.Maps;
-import java.net.URI;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
}
private void initQNames() {
- this.moduleQName = QNameModule.create(URI.create("urn:opendaylight.test2"), Revision.of("2015-08-08"));
+ this.moduleQName = QNameModule.create(XMLNamespace.of("urn:opendaylight.test2"), Revision.of("2015-08-08"));
this.rootQName = QName.create(moduleQName, "root");
this.listAQName = QName.create(moduleQName, "list-a");
this.listBQName = QName.create(moduleQName, "list-b");
package org.opendaylight.yangtools.odlext.model.api;
import com.google.common.collect.ImmutableList;
-import java.net.URI;
import java.util.Collection;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
*/
public final class OpenDaylightExtensionsConstants {
private static final String MODULE_NAME = "yang-ext";
- private static final URI MODULE_NAMESPACE = URI.create("urn:opendaylight:yang:extension:yang-ext");
+ private static final XMLNamespace MODULE_NAMESPACE =
+ XMLNamespace.of("urn:opendaylight:yang:extension:yang-ext").intern();
private static final Revision ORIGINAL_REVISION = Revision.of("2013-07-09");
/**
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
-import java.net.URI;
import java.util.Collection;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.opendaylight.yangtools.odlext.model.api.OpenDaylightExtensionsStatements;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
YangTextSchemaSource.forResource("/bugs/bug3874/yang-ext.yang")))
.buildEffective();
- QNameModule foo = QNameModule.create(URI.create("foo"));
+ QNameModule foo = QNameModule.create(XMLNamespace.of("foo"));
QName myContainer2QName = QName.create(foo, "my-container-2");
QName myAnyXmlDataQName = QName.create(foo, "my-anyxml-data");
package org.opendaylight.yangtools.openconfig.model.api;
import com.google.common.collect.ImmutableList;
-import java.net.URI;
import java.util.Collection;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
private static final String MODULE_NAME = "yang-ext";
// Package-visible, because openconfig-version applies across all known revisions and needs to bind to all of them
- static final URI MODULE_NAMESPACE = URI.create("http://openconfig.net/yang/openconfig-ext");
+ static final XMLNamespace MODULE_NAMESPACE = XMLNamespace.of("http://openconfig.net/yang/openconfig-ext").intern();
// Initial revision, defining semantic-version
private static final Revision SEMVER_REVISION = Revision.of("2015-10-09");
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
-import java.net.URI;
import java.util.Collection;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
@NonNullByDefault
public final class NetconfConstants {
private static final String MODULE_NAME = "ietf-netconf";
- private static final URI MODULE_NAMESPACE = URI.create("urn:ietf:params:xml:ns:netconf:base:1.0");
+ private static final XMLNamespace MODULE_NAMESPACE =
+ XMLNamespace.of("urn:ietf:params:xml:ns:netconf:base:1.0").intern();
private static final Revision RFC6241_REVISION = Revision.of("2011-06-01");
/**
package org.opendaylight.yangtools.rfc6536.model.api;
import com.google.common.collect.ImmutableList;
-import java.net.URI;
import java.util.Collection;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
@NonNullByDefault
public final class NACMConstants {
private static final String MODULE_NAME = "ietf-netconf-acm";
- private static final URI MODULE_NAMESPACE = URI.create("urn:ietf:params:xml:ns:yang:ietf-netconf-acm");
+ private static final XMLNamespace MODULE_NAMESPACE =
+ XMLNamespace.of("urn:ietf:params:xml:ns:yang:ietf-netconf-acm").intern();
private static final Revision RFC6536_REVISION = Revision.of("2012-02-22");
private static final Revision RFC8341_REVISION = Revision.of("2018-02-14");
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
-import java.net.URI;
import java.util.Collection;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
@Beta
public final class IetfYangSmiv2Constants {
private static final String MODULE_NAME = "ietf-yang-smiv2";
- private static final URI MODULE_NAMESPACE = URI.create("urn:ietf:params:xml:ns:yang:ietf-yang-smiv2");
+ private static final XMLNamespace MODULE_NAMESPACE =
+ XMLNamespace.of("urn:ietf:params:xml:ns:yang:ietf-yang-smiv2").intern();
private static final Revision RFC6643_REVISION = Revision.of("2012-06-22");
/**
package org.opendaylight.yangtools.rfc7952.model.api;
import com.google.common.collect.ImmutableList;
-import java.net.URI;
import java.util.Collection;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
@NonNullByDefault
public final class MetadataConstants {
private static final String MODULE_NAME = "ietf-yang-metadata";
- private static final URI MODULE_NAMESPACE = URI.create("urn:ietf:params:xml:ns:yang:ietf-yang-metadata");
+ private static final XMLNamespace MODULE_NAMESPACE =
+ XMLNamespace.of("urn:ietf:params:xml:ns:yang:ietf-yang-metadata").intern();
private static final Revision RFC7952_REVISION = Revision.of("2016-08-05");
/**
package org.opendaylight.yangtools.rfc8040.model.api;
import com.google.common.collect.ImmutableList;
-import java.net.URI;
import java.util.Collection;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
@NonNullByDefault
public final class YangDataConstants {
private static final String MODULE_NAME = "ietf-restconf";
- private static final URI MODULE_NAMESPACE = URI.create("urn:ietf:params:xml:ns:yang:ietf-restconf");
+ private static final XMLNamespace MODULE_NAMESPACE =
+ XMLNamespace.of("urn:ietf:params:xml:ns:yang:ietf-restconf").intern();
private static final Revision RFC8040_REVISION = Revision.of("2017-01-26");
/**
import com.google.common.collect.ImmutableSet;
import java.io.IOException;
-import java.net.URI;
import java.util.Collection;
import java.util.Optional;
import org.junit.AfterClass;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
import org.opendaylight.yangtools.yang.model.api.Module;
"/yang-data-extension-test/ietf-restconf.yang");
private static final Revision REVISION = Revision.of("2017-06-01");
- private static final QNameModule FOO_QNAMEMODULE = QNameModule.create(URI.create("foo"), REVISION);
+ private static final QNameModule FOO_QNAMEMODULE = QNameModule.create(XMLNamespace.of("foo"), REVISION);
private static final QName MY_YANG_DATA_A = QName.create(FOO_QNAMEMODULE, "my-yang-data-a");
private static final QName MY_YANG_DATA_B = QName.create(FOO_QNAMEMODULE, "my-yang-data-b");
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
-import java.net.URI;
import java.util.Arrays;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
/**
* Constants related to {@code ietf-yang-library.yang}. As schema-mount works in concert with yang-library, we need
* The namespace assigned to {@code ietf-yang-library}. This constant is required for XML-like parsers, using
* XML namespaces to reference modules.
*/
- public static final URI MODULE_NAMESPACE = URI.create("urn:ietf:params:xml:ns:yang:ietf-yang-library");
+ public static final XMLNamespace MODULE_NAMESPACE =
+ XMLNamespace.of("urn:ietf:params:xml:ns:yang:ietf-yang-library");
/**
* The module name assigned to {@code ietf-yang-library}. This constant is required for JSON-like parsers, using
* module names to reference modules.
package org.opendaylight.yangtools.rfc8528.model.api;
import com.google.common.collect.ImmutableList;
-import java.net.URI;
import java.util.Collection;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
@NonNullByDefault
public final class SchemaMountConstants {
private static final String MODULE_NAME = "ietf-yang-schema-mount";
- private static final URI MODULE_NAMESPACE = URI.create("urn:ietf:params:xml:ns:yang:ietf-yang-schema-mount");
+ private static final XMLNamespace MODULE_NAMESPACE =
+ XMLNamespace.of("urn:ietf:params:xml:ns:yang:ietf-yang-schema-mount").intern();
private static final Revision RFC8528_REVISION = Revision.of("2019-01-14");
/**
import static org.junit.Assert.assertEquals;
import java.io.IOException;
-import java.net.URI;
import java.util.List;
import java.util.stream.Collectors;
import org.junit.AfterClass;
import org.opendaylight.yangtools.rfc8528.model.api.MountPointSchemaNode;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor;
public class MountPointTest {
- private static final QNameModule EXAMPLE_USES = QNameModule.create(URI.create("http://example.org/example-uses"));
+ private static final QNameModule EXAMPLE_USES =
+ QNameModule.create(XMLNamespace.of("http://example.org/example-uses"));
private static final QName EXAMPLE_CONT = QName.create(EXAMPLE_USES, "cont");
private static final QName EXAMPLE_GRP = QName.create(EXAMPLE_USES, "grp");
private static final QName EXAMPLE_GRP_CONT = QName.create(EXAMPLE_USES, "grp-cont");
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
-import java.net.URI;
-import java.net.URISyntaxException;
import java.util.Objects;
import java.util.Optional;
import java.util.regex.Matcher;
* @param localName
* YANG schema identifier
*/
- private QName(final URI namespace, final String localName) {
+ private QName(final XMLNamespace namespace, final String localName) {
this(QNameModule.create(namespace), checkLocalName(localName));
}
}
matcher = QNAME_PATTERN_NO_REVISION.matcher(input);
if (matcher.matches()) {
- final URI namespace = URI.create(matcher.group(1));
+ final XMLNamespace namespace = XMLNamespace.of(matcher.group(1));
final String localName = matcher.group(2);
return new QName(namespace, localName);
}
* @param localName Local name part of QName. MUST NOT BE null.
* @return Instance of QName
*/
- public static @NonNull QName create(final URI namespace, final @Nullable Revision revision,
+ public static @NonNull QName create(final XMLNamespace namespace, final @Nullable Revision revision,
final String localName) {
return create(QNameModule.create(namespace, revision), localName);
}
* @param localName Local name part of QName. MUST NOT BE null.
* @return Instance of QName
*/
- public static @NonNull QName create(final URI namespace, final Optional<Revision> revision,
+ public static @NonNull QName create(final XMLNamespace namespace, final Optional<Revision> revision,
final String localName) {
return create(QNameModule.create(namespace, revision), localName);
}
* @return Instance of QName
*/
public static @NonNull QName create(final String namespace, final String localName, final Revision revision) {
- return create(QNameModule.create(parseNamespace(namespace), revision), localName);
+ return create(QNameModule.create(XMLNamespace.of(namespace), revision), localName);
}
/**
* to {@code YYYY-mm-dd}.
*/
public static @NonNull QName create(final String namespace, final String revision, final String localName) {
- return create(parseNamespace(namespace), Revision.of(revision), localName);
+ return create(XMLNamespace.of(namespace), Revision.of(revision), localName);
}
/**
* @throws IllegalArgumentException If {@code namespace} is not valid URI.
*/
public static @NonNull QName create(final String namespace, final String localName) {
- return create(parseNamespace(namespace), localName);
+ return create(XMLNamespace.of(namespace), localName);
}
/**
* @throws NullPointerException If any of parameters is null.
* @throws IllegalArgumentException If <code>namespace</code> is not valid URI.
*/
- public static @NonNull QName create(final URI namespace, final String localName) {
+ public static @NonNull QName create(final XMLNamespace namespace, final String localName) {
return new QName(namespace, localName);
}
*
* @return XMLNamespace assigned to the YANG module.
*/
- public @NonNull URI getNamespace() {
+ public @NonNull XMLNamespace getNamespace() {
return module.getNamespace();
}
return Objects.equals(getLocalName(), other.getLocalName()) && module.equals(other.module);
}
- private static @NonNull URI parseNamespace(final String namespace) {
- try {
- return new URI(namespace);
- } catch (final URISyntaxException ue) {
- throw new IllegalArgumentException("Namespace '" + namespace + "' is not a valid URI", ue);
- }
- }
-
@Override
public @NonNull String toString() {
final StringBuilder sb = new StringBuilder().append(QNAME_LEFT_PARENTHESIS).append(getNamespace());
import java.io.DataOutput;
import java.io.IOException;
import java.io.Serializable;
-import java.net.URI;
import java.util.Objects;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
private static final Interner<QNameModule> INTERNER = Interners.newWeakInterner();
private static final long serialVersionUID = 3L;
- private final @NonNull URI namespace;
+ private final @NonNull XMLNamespace namespace;
private final @Nullable Revision revision;
private transient int hash = 0;
- private QNameModule(final URI namespace, final @Nullable Revision revision) {
+ private QNameModule(final XMLNamespace namespace, final @Nullable Revision revision) {
this.namespace = requireNonNull(namespace);
this.revision = revision;
}
* @return A new, potentially shared, QNameModule instance
* @throws NullPointerException if any argument is null
*/
- public static @NonNull QNameModule create(final URI namespace, final Optional<Revision> revision) {
+ public static @NonNull QNameModule create(final XMLNamespace namespace, final Optional<Revision> revision) {
return new QNameModule(namespace, revision.orElse(null));
}
* @return A new, potentially shared, QNameModule instance
* @throws NullPointerException if {@code namespace} is null
*/
- public static @NonNull QNameModule create(final URI namespace) {
+ public static @NonNull QNameModule create(final XMLNamespace namespace) {
return new QNameModule(namespace, null);
}
* @return A new, potentially shared, QNameModule instance
* @throws NullPointerException if any argument is null
*/
- public static @NonNull QNameModule create(final URI namespace, final @Nullable Revision revision) {
+ public static @NonNull QNameModule create(final XMLNamespace namespace, final @Nullable Revision revision) {
return new QNameModule(namespace, revision);
}
public static @NonNull QNameModule readFrom(final DataInput in) throws IOException {
final String namespace = in.readUTF();
final String revision = in.readUTF();
- return new QNameModule(URI.create(namespace), revision.isEmpty() ? null : Revision.of(revision));
+ return new QNameModule(XMLNamespace.of(namespace), revision.isEmpty() ? null : Revision.of(revision));
}
/**
* Returns the namespace of the module which is specified as argument of YANG Module {@code namespace} keyword.
*
- * @return URI format of the namespace of the module
+ * @return XMLNamespace of the namespace of the module
*/
- public @NonNull URI getNamespace() {
+ public @NonNull XMLNamespace getNamespace() {
return namespace;
}
--- /dev/null
+/*
+ * Copyright (c) 2021 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.common;
+
+import static java.util.Objects.requireNonNull;
+
+import com.google.common.collect.Interner;
+import com.google.common.collect.Interners;
+import java.io.Serializable;
+import java.net.URI;
+import java.net.URISyntaxException;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.concepts.Immutable;
+
+/**
+ * A simple type capture of {@code namespace} statement's argument according to
+ * <a href="https://tools.ietf.org/html/rfc6020#section-7.1.3">RFC6020</a>.
+ */
+public final class XMLNamespace implements Comparable<XMLNamespace>, Immutable, Serializable {
+ private static final Interner<XMLNamespace> INTERNER = Interners.newWeakInterner();
+ private static final long serialVersionUID = 1L;
+
+ private final String namespace;
+
+ private XMLNamespace(final String namespace) {
+ this.namespace = requireNonNull(namespace);
+ }
+
+ // FIXME: add documentation
+ public static @NonNull XMLNamespace of(final String namespace) {
+ try {
+ // Validation only
+ new URI(namespace);
+ } catch (final URISyntaxException e) {
+ throw new IllegalArgumentException("Namespace '" + namespace + "' is not a valid URI", e);
+ }
+
+ return new XMLNamespace(namespace);
+ }
+
+ /**
+ * Return an interned reference to a equivalent XMLNamespace.
+ *
+ * @return Interned reference, or this object if it was interned.
+ */
+ public @NonNull XMLNamespace intern() {
+ return INTERNER.intern(this);
+ }
+
+ @Override
+ @SuppressWarnings("checkstyle:parameterName")
+ public int compareTo(final XMLNamespace o) {
+ return namespace.compareTo(o.namespace);
+ }
+
+ @Override
+ public int hashCode() {
+ return namespace.hashCode();
+ }
+
+ @Override
+ public boolean equals(final Object obj) {
+ return this == obj || obj instanceof XMLNamespace && namespace.equals(((XMLNamespace) obj).namespace);
+ }
+
+ @Override
+ public String toString() {
+ return namespace;
+ }
+
+ Object writeReplace() {
+ return new XNv1(this);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2021 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.common;
+
+import static com.google.common.base.Verify.verifyNotNull;
+import static java.util.Objects.requireNonNull;
+
+import java.io.Externalizable;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+
+/**
+ * Externalizable proxy for {@link XMLNamespace}.
+ */
+final class XNv1 implements Externalizable {
+
+ private XMLNamespace namespace;
+
+ @SuppressWarnings("checkstyle:redundantModifier")
+ public XNv1() {
+ // For Externalizable
+ }
+
+ XNv1(final XMLNamespace namespace) {
+ this.namespace = requireNonNull(namespace);
+ }
+
+ @Override
+ public void writeExternal(final ObjectOutput out) throws IOException {
+ out.writeUTF(namespace.toString());
+ }
+
+ @Override
+ public void readExternal(final ObjectInput in) throws IOException {
+ try {
+ namespace = XMLNamespace.of(in.readUTF());
+ } catch (IllegalArgumentException e) {
+ throw new IOException("Invalid namespace", e);
+ }
+ }
+
+ Object readResolve() {
+ return verifyNotNull(namespace);
+ }
+}
/**
* YANG namespace, as defined in https://tools.ietf.org/html/rfc6020#section-14, in URI format.
*/
- public static final URI RFC6020_YANG_NAMESPACE = URI.create(RFC6020_YANG_NAMESPACE_STRING);
+ public static final XMLNamespace RFC6020_YANG_NAMESPACE = XMLNamespace.of(RFC6020_YANG_NAMESPACE_STRING).intern();
/**
* Base QNameModule for all YANG statements.
/**
* YIN namespace, as defined in https://tools.ietf.org/html/rfc6020#section-14, in URI format.
*/
- public static final URI RFC6020_YIN_NAMESPACE = URI.create(RFC6020_YIN_NAMESPACE_STRING);
+ public static final XMLNamespace RFC6020_YIN_NAMESPACE = XMLNamespace.of(RFC6020_YIN_NAMESPACE_STRING).intern();
/**
* Base QNameModule for all YIN statements.
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
-import java.net.URI;
import java.util.Optional;
import org.junit.Test;
public class BiMapYangNamespaceContextTest {
- private static final QNameModule FOO = QNameModule.create(URI.create("foo"));
- private static final QNameModule BAR = QNameModule.create(URI.create("bar"));
- private static final QNameModule BAZ = QNameModule.create(URI.create("baz"));
+ private static final QNameModule FOO = QNameModule.create(XMLNamespace.of("foo"));
+ private static final QNameModule BAR = QNameModule.create(XMLNamespace.of("bar"));
+ private static final QNameModule BAZ = QNameModule.create(XMLNamespace.of("baz"));
private final BiMapYangNamespaceContext context = new BiMapYangNamespaceContext(
ImmutableBiMap.of("foo", FOO, "bar", BAR));
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
-import java.net.URI;
import java.net.URISyntaxException;
import org.junit.Test;
private static final String NAMESPACE = "urn:foo";
private static final String REVISION = "2013-12-24";
private static final String LOCALNAME = "bar";
- private static final URI NS = URI.create(NAMESPACE);
+ private static final XMLNamespace NS = XMLNamespace.of(NAMESPACE);
@Test
public void testStringSerialization() throws Exception {
assertTrue(qb.compareTo(qa) > 0);
// compare with 1 null revision
- qa = QName.create(URI.create(A), A);
- qb = QName.create(URI.create(A), Revision.of(REVISION), A);
+ qa = QName.create(XMLNamespace.of(A), A);
+ qb = QName.create(XMLNamespace.of(A), Revision.of(REVISION), A);
assertTrue(qa.compareTo(qb) < 0);
assertTrue(qb.compareTo(qa) > 0);
// compare with both null revision
- qb = QName.create(URI.create(A), A);
+ qb = QName.create(XMLNamespace.of(A), A);
assertTrue(qa.compareTo(qb) == 0);
assertTrue(qb.compareTo(qa) == 0);
}
import static org.junit.Assert.assertEquals;
-import java.net.URI;
import org.junit.Test;
public class YangConstantsTest {
-
@Test
public void testYangConstants() {
- final URI uriYang = YangConstants.RFC6020_YANG_NAMESPACE;
- final URI uriYin = YangConstants.RFC6020_YIN_NAMESPACE;
- assertEquals(URI.create("urn:ietf:params:xml:ns:yang:1"), uriYang);
- assertEquals(URI.create("urn:ietf:params:xml:ns:yang:yin:1"), uriYin);
+ final XMLNamespace uriYang = YangConstants.RFC6020_YANG_NAMESPACE;
+ final XMLNamespace uriYin = YangConstants.RFC6020_YIN_NAMESPACE;
+ assertEquals(XMLNamespace.of("urn:ietf:params:xml:ns:yang:1"), uriYang);
+ assertEquals(XMLNamespace.of("urn:ietf:params:xml:ns:yang:yin:1"), uriYin);
assertEquals(QNameModule.create(uriYang).intern(), YangConstants.RFC6020_YANG_MODULE);
assertEquals(QNameModule.create(uriYin).intern(), YangConstants.RFC6020_YIN_MODULE);
}
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
-import java.net.URI;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.opendaylight.yangtools.concepts.WritableObject;
import org.opendaylight.yangtools.util.AbstractIdentifier;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
/**
* Identifier of a RFC8342 (NMDA) datastore. This class is backed by the QName of the datastore, i.e.
public final class DatastoreIdentifier extends AbstractIdentifier<QName> implements WritableObject {
private static final long serialVersionUID = 1L;
- private static final URI IETF_DATASTORES_NAMESPACE = URI.create("urn:ietf:params:xml:ns:yang:ietf-datastores");
+ private static final XMLNamespace IETF_DATASTORES_NAMESPACE =
+ XMLNamespace.of("urn:ietf:params:xml:ns:yang:ietf-datastores").intern();
private static final ImmutableSet<String> KNOWN_ABSTRACTS = ImmutableSet.of("datastore", "conventional", "dynamic");
private static final LoadingCache<QName, DatastoreIdentifier> CACHE = CacheBuilder.newBuilder().weakValues()
import static org.junit.Assert.assertTrue;
import com.google.common.collect.UnmodifiableIterator;
-import java.net.URI;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
@Test
public void testPathArgument() {
- final QNameModule qNameModule = QNameModule.create(URI.create("urn:opendaylight.test2"),
+ final QNameModule qNameModule = QNameModule.create(XMLNamespace.of("urn:opendaylight.test2"),
Revision.of("2015-08-08"));
final QName qNameRoot = QName.create(qNameModule, "root");
final QName qNameList = QName.create(qNameModule, "list");
import static org.mockito.Mockito.mock;
import java.io.IOException;
-import java.net.URI;
import java.util.Set;
import javax.xml.transform.dom.DOMSource;
import org.junit.Before;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
@Before
public void setUp() {
- bazModule = QNameModule.create(URI.create("baz-namespace"), Revision.of("1970-01-01"));
+ bazModule = QNameModule.create(XMLNamespace.of("baz-namespace"), Revision.of("1970-01-01"));
myKeyedList = QName.create(bazModule, "my-keyed-list");
myKeyLeaf = QName.create(bazModule, "my-key-leaf");
myLeafList = QName.create(bazModule, "my-leaf-list");
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
-import java.net.URI;
import java.util.Objects;
import java.util.concurrent.ExecutionException;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
final class QNameFactory {
}
QNameModule toQNameModule() {
- return QNameModule.create(URI.create(namespace), Revision.ofNullable(revision));
+ return QNameModule.create(XMLNamespace.of(namespace), Revision.ofNullable(revision));
}
}
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
-import java.net.URI;
import java.util.Iterator;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.util.AbstractModuleStringInstanceIdentifierCodec;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
}
@Override
- protected final String prefixForNamespace(final URI namespace) {
+ protected final String prefixForNamespace(final XMLNamespace namespace) {
final Iterator<? extends Module> modules = context.findModules(namespace).iterator();
return modules.hasNext() ? modules.next().getName() : null;
}
import com.google.common.collect.ImmutableClassToInstanceMap;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
-import java.net.URI;
import java.util.regex.Pattern;
import javax.xml.transform.dom.DOMSource;
import org.checkerframework.checker.regex.qual.Regex;
import org.opendaylight.yangtools.rfc8528.data.api.MountPointContext;
import org.opendaylight.yangtools.rfc8528.data.api.MountPointIdentifier;
import org.opendaylight.yangtools.rfc8528.data.api.StreamWriterMountPointExtension;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
* @return A stream writer instance
*/
public static NormalizedNodeStreamWriter createExclusiveWriter(final JSONCodecFactory codecFactory,
- final SchemaPath path, final URI initialNs, final JsonWriter jsonWriter) {
+ final SchemaPath path, final XMLNamespace initialNs, final JsonWriter jsonWriter) {
return new Exclusive(codecFactory, SchemaTracker.create(codecFactory.getEffectiveModelContext(), path),
jsonWriter, new JSONStreamWriterExclusiveRootContext(initialNs));
}
* @return A stream writer instance
*/
public static NormalizedNodeStreamWriter createExclusiveWriter(final JSONCodecFactory codecFactory,
- final Absolute path, final URI initialNs, final JsonWriter jsonWriter) {
+ final Absolute path, final XMLNamespace initialNs, final JsonWriter jsonWriter) {
return new Exclusive(codecFactory, SchemaTracker.create(codecFactory.getEffectiveModelContext(), path),
jsonWriter, new JSONStreamWriterExclusiveRootContext(initialNs));
}
* @return A stream writer instance
*/
public static NormalizedNodeStreamWriter createExclusiveWriter(final JSONCodecFactory codecFactory,
- final DataNodeContainer rootNode, final URI initialNs, final JsonWriter jsonWriter) {
+ final DataNodeContainer rootNode, final XMLNamespace initialNs, final JsonWriter jsonWriter) {
return new Exclusive(codecFactory, SchemaTracker.create(rootNode), jsonWriter,
new JSONStreamWriterExclusiveRootContext(initialNs));
}
* @return A stream writer instance
*/
public static NormalizedNodeStreamWriter createNestedWriter(final JSONCodecFactory codecFactory,
- final SchemaPath path, final URI initialNs, final JsonWriter jsonWriter) {
+ final SchemaPath path, final XMLNamespace initialNs, final JsonWriter jsonWriter) {
return new Nested(codecFactory, SchemaTracker.create(codecFactory.getEffectiveModelContext(), path), jsonWriter,
new JSONStreamWriterSharedRootContext(initialNs));
}
* @return A stream writer instance
*/
public static NormalizedNodeStreamWriter createNestedWriter(final JSONCodecFactory codecFactory,
- final Absolute path, final URI initialNs, final JsonWriter jsonWriter) {
+ final Absolute path, final XMLNamespace initialNs, final JsonWriter jsonWriter) {
return new Nested(codecFactory, SchemaTracker.create(codecFactory.getEffectiveModelContext(), path), jsonWriter,
new JSONStreamWriterSharedRootContext(initialNs));
}
* @return A stream writer instance
*/
public static NormalizedNodeStreamWriter createNestedWriter(final JSONCodecFactory codecFactory,
- final DataNodeContainer rootNode, final URI initialNs, final JsonWriter jsonWriter) {
+ final DataNodeContainer rootNode, final XMLNamespace initialNs, final JsonWriter jsonWriter) {
return new Nested(codecFactory, SchemaTracker.create(rootNode), jsonWriter,
new JSONStreamWriterSharedRootContext(initialNs));
}
import com.google.common.base.MoreObjects.ToStringHelper;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
-import java.net.URI;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.Module;
*
* @return Namespace as URI
*/
- protected abstract @NonNull URI getNamespace();
+ protected abstract @NonNull XMLNamespace getNamespace();
/**
* Emit the start of an element.
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
-import java.net.URI;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
final class JSONStreamWriterExclusiveRootContext extends JSONStreamWriterRootContext {
- JSONStreamWriterExclusiveRootContext(final URI namespace) {
+ JSONStreamWriterExclusiveRootContext(final XMLNamespace namespace) {
super(namespace, true);
}
import static java.util.Objects.requireNonNull;
-import java.net.URI;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
/**
* Abstract base class for {@link JSONNormalizedNodeStreamWriter} recursion
}
@Override
- protected final URI getNamespace() {
+ protected final XMLNamespace getNamespace() {
return qname.getNamespace();
}
}
*/
package org.opendaylight.yangtools.yang.data.codec.gson;
-import java.net.URI;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
/**
* The root node of a particular {@link JSONNormalizedNodeStreamWriter} instance.
* It holds the base namespace and can never be removed from the stack.
*/
abstract class JSONStreamWriterRootContext extends JSONStreamWriterURIContext {
- JSONStreamWriterRootContext(final URI namespace, final boolean mandatory) {
+ JSONStreamWriterRootContext(final XMLNamespace namespace, final boolean mandatory) {
super(null, namespace, mandatory);
}
}
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
-import java.net.URI;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
final class JSONStreamWriterSharedRootContext extends JSONStreamWriterRootContext {
- JSONStreamWriterSharedRootContext(final URI namespace) {
+ JSONStreamWriterSharedRootContext(final XMLNamespace namespace) {
super(namespace, false);
}
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
-import java.net.URI;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
/**
* recursion. It only tracks the namespace associated with this node.
*/
abstract class JSONStreamWriterURIContext extends JSONStreamWriterContext {
- private final URI namespace;
+ private final XMLNamespace namespace;
- JSONStreamWriterURIContext(final JSONStreamWriterContext parent, final URI namespace) {
+ JSONStreamWriterURIContext(final JSONStreamWriterContext parent, final XMLNamespace namespace) {
this(parent, namespace, false);
}
- JSONStreamWriterURIContext(final JSONStreamWriterContext parent, final URI namespace, final boolean mandatory) {
+ JSONStreamWriterURIContext(final JSONStreamWriterContext parent, final XMLNamespace namespace,
+ final boolean mandatory) {
super(parent, mandatory);
this.namespace = namespace;
}
@Override
- protected final URI getNamespace() {
+ protected final XMLNamespace getNamespace() {
return namespace;
}
import java.io.EOFException;
import java.io.Flushable;
import java.io.IOException;
-import java.net.URI;
import java.util.AbstractMap.SimpleImmutableEntry;
import java.util.ArrayDeque;
import java.util.Deque;
import javax.xml.transform.dom.DOMSource;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.util.AbstractNodeDataWithSchema;
import org.opendaylight.yangtools.yang.data.util.AnyXmlNodeDataWithSchema;
static final String ANYXML_ARRAY_ELEMENT_ID = "array-element";
private static final Logger LOG = LoggerFactory.getLogger(JsonParserStream.class);
- private final Deque<URI> namespaces = new ArrayDeque<>();
+ private final Deque<XMLNamespace> namespaces = new ArrayDeque<>();
private final NormalizedNodeStreamWriter writer;
private final JSONCodecFactory codecs;
private final DataSchemaNode parentNode;
while (in.hasNext()) {
final String jsonElementName = in.nextName();
final DataSchemaNode parentSchema = parent.getSchema();
- final Entry<String, URI> namespaceAndName = resolveNamespace(jsonElementName, parentSchema);
+ final Entry<String, XMLNamespace> namespaceAndName =
+ resolveNamespace(jsonElementName, parentSchema);
final String localName = namespaceAndName.getKey();
- final URI namespace = namespaceAndName.getValue();
+ final XMLNamespace namespace = namespaceAndName.getValue();
if (lenient && (localName == null || namespace == null)) {
LOG.debug("Schema node with name {} was not found under {}", localName,
parentSchema.getQName());
namespaces.pop();
}
- private void addNamespace(final URI namespace) {
+ private void addNamespace(final XMLNamespace namespace) {
namespaces.push(namespace);
}
- private Entry<String, URI> resolveNamespace(final String childName, final DataSchemaNode dataSchemaNode) {
+ private Entry<String, XMLNamespace> resolveNamespace(final String childName, final DataSchemaNode dataSchemaNode) {
final int lastIndexOfColon = childName.lastIndexOf(':');
String moduleNamePart = null;
String nodeNamePart = null;
- URI namespace = null;
+ XMLNamespace namespace = null;
if (lastIndexOfColon != -1) {
moduleNamePart = childName.substring(0, lastIndexOfColon);
nodeNamePart = childName.substring(lastIndexOfColon + 1);
}
if (namespace == null) {
- final Set<URI> potentialUris = resolveAllPotentialNamespaces(nodeNamePart, dataSchemaNode);
+ final Set<XMLNamespace> potentialUris = resolveAllPotentialNamespaces(nodeNamePart, dataSchemaNode);
if (potentialUris.contains(getCurrentNamespace())) {
namespace = getCurrentNamespace();
} else if (potentialUris.size() == 1) {
return new SimpleImmutableEntry<>(nodeNamePart, namespace);
}
- private String toModuleNames(final Set<URI> potentialUris) {
+ private String toModuleNames(final Set<XMLNamespace> potentialUris) {
final StringBuilder builder = new StringBuilder();
- for (final URI potentialUri : potentialUris) {
+ for (final XMLNamespace potentialUri : potentialUris) {
builder.append('\n');
//FIXME how to get information about revision from JSON input? currently first available is used.
builder.append(codecs.getEffectiveModelContext().findModules(potentialUri).iterator().next().getName());
return builder.toString();
}
- private Set<URI> resolveAllPotentialNamespaces(final String elementName, final DataSchemaNode dataSchemaNode) {
- final Set<URI> potentialUris = new HashSet<>();
+ private Set<XMLNamespace> resolveAllPotentialNamespaces(final String elementName,
+ final DataSchemaNode dataSchemaNode) {
+ final Set<XMLNamespace> potentialUris = new HashSet<>();
final Set<ChoiceSchemaNode> choices = new HashSet<>();
if (dataSchemaNode instanceof DataNodeContainer) {
for (final DataSchemaNode childSchemaNode : ((DataNodeContainer) dataSchemaNode).getChildNodes()) {
return potentialUris;
}
- private URI getCurrentNamespace() {
+ private XMLNamespace getCurrentNamespace() {
return namespaces.peek();
}
import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
-import java.net.URI;
import java.net.URISyntaxException;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
public class Bug5446Test {
- private static final QNameModule FOO_MODULE = QNameModule.create(URI.create("foo"), Revision.of("2015-11-05"));
+ private static final QNameModule FOO_MODULE = QNameModule.create(XMLNamespace.of("foo"), Revision.of("2015-11-05"));
private static final QName ROOT_QNAME = QName.create(FOO_MODULE, "root");
private static final QName IP_ADDRESS_QNAME = QName.create(FOO_MODULE, "ip-address");
private static EffectiveModelContext schemaContext;
import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
-import java.net.URI;
import java.nio.charset.StandardCharsets;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
final NormalizedNodeStreamWriter jsonStream = JSONNormalizedNodeStreamWriter.createExclusiveWriter(
JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02.getShared(schemaContext), path,
- URI.create(NS), JsonWriterFactory.createJsonWriter(writer, 2));
+ XMLNamespace.of(NS), JsonWriterFactory.createJsonWriter(writer, 2));
final NormalizedNodeWriter nodeWriter = NormalizedNodeWriter.forStreamWriter(jsonStream);
nodeWriter.write(inputStructure);
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.io.StringReader;
-import java.net.URI;
import java.net.URISyntaxException;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.mockito.ArgumentCaptor;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class Bug8083Test {
- private static final QNameModule FOOMOD = QNameModule.create(URI.create("http://example.com/foomod"));
- private static final QNameModule BARMOD = QNameModule.create(URI.create("http://example.com/barmod"));
+ private static final QNameModule FOOMOD = QNameModule.create(XMLNamespace.of("http://example.com/foomod"));
+ private static final QNameModule BARMOD = QNameModule.create(XMLNamespace.of("http://example.com/barmod"));
private static final QName FOO_QNAME = QName.create(FOOMOD, "foo");
private static final QName FOOLIST_QNAME = QName.create(FOOMOD, "foo-list");
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
-import java.net.URI;
import java.util.Arrays;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
public final class TestingNormalizedNodeStructuresCreator {
- private static final QNameModule COMPLEX_JSON = QNameModule.create(URI.create("ns:complex:json"),
- Revision.of("2014-08-11"));
- private static final QNameModule COMPLEX_JSON_AUG = QNameModule.create(URI.create("ns:complex:json:augmentation"),
- Revision.of("2014-08-14"));
+ private static final QNameModule COMPLEX_JSON =
+ QNameModule.create(XMLNamespace.of("ns:complex:json"), Revision.of("2014-08-11"));
+ private static final QNameModule COMPLEX_JSON_AUG =
+ QNameModule.create(XMLNamespace.of("ns:complex:json:augmentation"), Revision.of("2014-08-14"));
private TestingNormalizedNodeStructuresCreator() {
throw new UnsupportedOperationException();
import static com.google.common.base.Preconditions.checkArgument;
import static java.util.Objects.requireNonNull;
-import java.net.URI;
import java.util.Iterator;
import java.util.Map.Entry;
import javax.xml.namespace.NamespaceContext;
import javax.xml.stream.XMLStreamWriter;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.util.codec.IdentityCodecUtil;
import org.opendaylight.yangtools.yang.data.util.codec.QNameCodecUtil;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
}
final String prefixedNS = ctx.getNamespaceURI(prefix);
- final Iterator<? extends Module> modules = schemaContext.findModules(URI.create(prefixedNS)).iterator();
+ final Iterator<? extends Module> modules =
+ schemaContext.findModules(XMLNamespace.of(prefixedNS)).iterator();
checkArgument(modules.hasNext(), "Could not find module for namespace %s", prefixedNS);
return modules.next().getQNameModule();
}).getQName();
final RandomPrefix prefixes = new RandomPrefix(ctx.getNamespaceContext());
final String str = QNameCodecUtil.encodeQName(value, uri -> prefixes.encodePrefix(uri.getNamespace()));
- for (Entry<URI, String> e : prefixes.getPrefixes()) {
+ for (Entry<XMLNamespace, String> e : prefixes.getPrefixes()) {
ctx.writeNamespace(e.getValue(), e.getKey().toString());
}
ctx.writeCharacters(str);
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
-import java.net.URI;
import java.util.Map.Entry;
import javax.xml.XMLConstants;
import javax.xml.namespace.NamespaceContext;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
class RandomPrefix {
// 32 characters, carefully chosen
private int counter = 0;
// BiMap to make values lookup faster
- private final BiMap<URI, String> prefixes = HashBiMap.create();
+ private final BiMap<XMLNamespace, String> prefixes = HashBiMap.create();
private final NamespaceContext context;
RandomPrefix(final NamespaceContext context) {
this.context = context;
}
- Iterable<Entry<URI, String>> getPrefixes() {
+ Iterable<Entry<XMLNamespace, String>> getPrefixes() {
return prefixes.entrySet();
}
- String encodePrefix(final URI namespace) {
+ String encodePrefix(final XMLNamespace namespace) {
String prefix = prefixes.get(namespace);
if (prefix != null) {
return prefix;
*/
package org.opendaylight.yangtools.yang.data.codec.xml;
-import java.net.URI;
import java.util.Map.Entry;
import javax.xml.namespace.NamespaceContext;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.util.AbstractStringInstanceIdentifierCodec;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
prefixes = new RandomPrefix(nsContext);
}
- Iterable<Entry<URI, String>> getPrefixes() {
+ Iterable<Entry<XMLNamespace, String>> getPrefixes() {
return prefixes.getPrefixes();
}
@Override
- protected String prefixForNamespace(final URI namespace) {
+ protected String prefixForNamespace(final XMLNamespace namespace) {
return prefixes.encodePrefix(namespace);
}
import static com.google.common.base.Verify.verifyNotNull;
import static java.util.Objects.requireNonNull;
-import java.net.URI;
import java.util.Map.Entry;
import javax.xml.stream.XMLStreamException;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextProvider;
writer.getNamespaceContext());
String serializedValue = iiCodec.serialize(value);
- for (Entry<URI, String> e : iiCodec.getPrefixes()) {
+ for (Entry<XMLNamespace, String> e : iiCodec.getPrefixes()) {
writer.writeNamespace(e.getValue(), e.getKey().toString());
}
import com.google.common.base.Strings;
import java.io.IOException;
-import java.net.URI;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import javax.xml.XMLConstants;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.XMLStreamWriter;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedAnydata;
import org.opendaylight.yangtools.yang.data.util.SingleChildDataNodeContainer;
import org.slf4j.Logger;
}
}
- String getPrefix(final URI uri, final String str) throws XMLStreamException {
+ String getPrefix(final XMLNamespace uri, final String str) throws XMLStreamException {
final String prefix = writer.getPrefix(str);
if (prefix != null) {
return prefix;
import java.io.Closeable;
import java.io.Flushable;
import java.io.IOException;
-import java.net.URI;
import java.net.URISyntaxException;
import java.util.AbstractMap.SimpleImmutableEntry;
import java.util.Deque;
import org.opendaylight.yangtools.rfc8528.model.api.SchemaMountConstants;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
import org.opendaylight.yangtools.yang.data.util.AbstractMountPointDataWithSchema;
import org.opendaylight.yangtools.yang.data.util.AbstractNodeDataWithSchema;
* annotations.
*/
@Deprecated
- public static final QNameModule LEGACY_ATTRIBUTE_NAMESPACE = QNameModule.create(URI.create("")).intern();
+ public static final QNameModule LEGACY_ATTRIBUTE_NAMESPACE = QNameModule.create(XMLNamespace.of("")).intern();
private static final Logger LOG = LoggerFactory.getLogger(XmlParserStream.class);
private static final String XML_STANDARD_VERSION = "1.0";
final String elementNS = in.getNamespaceURI();
final boolean added = namesakes.add(new SimpleImmutableEntry<>(elementNS, xmlElementName));
- final URI nsUri;
+ final XMLNamespace nsUri;
try {
nsUri = rawXmlNamespace(elementNS).getNamespace();
} catch (IllegalArgumentException e) {
return last instanceof ListSchemaNode || last instanceof LeafListSchemaNode;
}
- private static void addMountPointChild(final MountPointData mount, final URI namespace, final String localName,
- final DOMSource source) {
+ private static void addMountPointChild(final MountPointData mount, final XMLNamespace namespace,
+ final String localName, final DOMSource source) {
final DOMSourceMountPointChild child = new DOMSourceMountPointChild(source);
if (YangLibraryConstants.MODULE_NAMESPACE.equals(namespace)) {
final Optional<ContainerName> optName = ContainerName.forLocalName(localName);
private Optional<QNameModule> resolveXmlNamespace(final String xmlNamespace) {
return resolvedNamespaces.computeIfAbsent(xmlNamespace, nsUri -> {
- final Iterator<? extends Module> it = codecs.getEffectiveModelContext().findModules(URI.create(nsUri))
+ final Iterator<? extends Module> it = codecs.getEffectiveModelContext().findModules(XMLNamespace.of(nsUri))
.iterator();
return it.hasNext() ? Optional.of(it.next().getQNameModule()) : Optional.empty();
});
}
private QNameModule rawXmlNamespace(final String xmlNamespace) {
- return rawNamespaces.computeIfAbsent(xmlNamespace, nsUri -> QNameModule.create(URI.create(nsUri)));
+ return rawNamespaces.computeIfAbsent(xmlNamespace, nsUri -> QNameModule.create(XMLNamespace.of(nsUri)));
}
}
import static com.google.common.base.Preconditions.checkArgument;
import static java.util.Objects.requireNonNull;
-import java.net.URI;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Iterator;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.util.AbstractModuleStringInstanceIdentifierCodec;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
@Override
protected Module moduleForPrefix(final String prefix) {
final String prefixedNS = getNamespaceContext().getNamespaceURI(prefix);
- final Iterator<? extends Module> modules = context.findModules(URI.create(prefixedNS)).iterator();
+ final Iterator<? extends Module> modules = context.findModules(XMLNamespace.of(prefixedNS)).iterator();
return modules.hasNext() ? modules.next() : null;
}
@Override
- protected String prefixForNamespace(final URI namespace) {
+ protected String prefixForNamespace(final XMLNamespace namespace) {
final Iterator<? extends Module> modules = context.findModules(namespace).iterator();
return modules.hasNext() ? modules.next().getName() : null;
}
import static org.junit.Assert.fail;
import java.io.InputStream;
-import java.net.URI;
import javax.xml.stream.XMLStreamReader;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
private EffectiveModelContext schemaContext;
@Before
- public void setUp() throws Exception {
- fooModuleQName = QNameModule.create(new URI("foo"), Revision.of("2016-03-22"));
+ public void setUp() {
+ fooModuleQName = QNameModule.create(XMLNamespace.of("foo"), Revision.of("2016-03-22"));
schemaContext = YangParserTestUtils.parseYangResource("/bug5396/yang/foo.yang");
}
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
-import java.net.URI;
import java.util.Base64;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.xml.sax.SAXException;
public class Bug5446Test extends XMLTestCase {
- private static final QNameModule FOO_MODULE = QNameModule.create(URI.create("foo"), Revision.of("2015-11-05"));
+ private static final QNameModule FOO_MODULE = QNameModule.create(XMLNamespace.of("foo"), Revision.of("2015-11-05"));
private static final QName ROOT_QNAME = QName.create(FOO_MODULE, "root");
private static final QName IP_ADDRESS_QNAME = QName.create(FOO_MODULE, "ip-address");
import static org.junit.Assert.assertTrue;
import java.io.InputStream;
-import java.net.URI;
import java.util.Collection;
import java.util.Optional;
import javax.xml.stream.XMLStreamReader;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class Bug890Test {
- private static final QNameModule FOO_MODULE = QNameModule.create(URI.create("foo"), Revision.of("2018-07-10"));
+ private static final QNameModule FOO_MODULE = QNameModule.create(XMLNamespace.of("foo"), Revision.of("2018-07-10"));
private static final QName OUTGOING_LABELS_QNAME = QName.create(FOO_MODULE, "outgoing-labels");
private static final QName INDEX_QNAME = QName.create(FOO_MODULE, "index");
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
-import java.net.URI;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.Uint32;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
}
private static NodeIdentifier getNodeIdentifier(final String localName) {
- return new NodeIdentifier(QName.create(URI.create(NAMESPACE), REVISION, localName));
+ return new NodeIdentifier(QName.create(XMLNamespace.of(NAMESPACE), REVISION, localName));
}
private static AugmentationIdentifier getAugmentIdentifier(final String... childNames) {
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
-import java.net.URI;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
@Before
public void setup() {
- bazModule = QNameModule.create(URI.create("baz-namespace"));
+ bazModule = QNameModule.create(XMLNamespace.of("baz-namespace"));
outerContainer = QName.create(bazModule, "outer-container");
import static org.junit.Assert.assertEquals;
import com.google.common.collect.Iterables;
-import java.net.URI;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
public class RandomPrefixTest {
static final int MAX_COUNTER = 4000;
}
@Test
- public void testQNameWithPrefix() throws Exception {
+ public void testQNameWithPrefix() {
final RandomPrefix a = new RandomPrefix(null);
final List<String> allGenerated = new ArrayList<>();
for (int i = 0; i < MAX_COUNTER; i++) {
final String prefix = RandomPrefix.encode(i);
- final URI uri = new URI("localhost:" + prefix);
+ final XMLNamespace uri = XMLNamespace.of("localhost:" + prefix);
final QName qname = QName.create(QNameModule.create(uri, Revision.of("2000-01-01")), "local-name");
allGenerated.add(a.encodePrefix(qname.getNamespace()));
}
public void test2QNames1Namespace() throws Exception {
final RandomPrefix a = new RandomPrefix(null);
- final URI uri = URI.create("localhost");
+ final XMLNamespace uri = XMLNamespace.of("localhost");
final QName qname = QName.create(QNameModule.create(uri, Revision.of("2000-01-01")), "local-name");
final QName qname2 = QName.create(QNameModule.create(uri, Revision.of("2000-01-01")), "local-name");
public void testQNameNoPrefix() throws Exception {
final RandomPrefix a = new RandomPrefix(null);
- final URI uri = URI.create("localhost");
+ final XMLNamespace uri = XMLNamespace.of("localhost");
QName qname = QName.create(uri, Revision.of("2000-01-01"), "local-name");
assertEquals("a", a.encodePrefix(qname.getNamespace()));
qname = QName.create(QNameModule.create(uri, Revision.of("2000-01-01")), "local-name");
assertEquals("a", a.encodePrefix(qname.getNamespace()));
- qname = QName.create(QNameModule.create(URI.create("second"), Revision.of("2000-01-01")), "local-name");
+ qname = QName.create(QNameModule.create(XMLNamespace.of("second"), Revision.of("2000-01-01")), "local-name");
assertEquals("b", a.encodePrefix(qname.getNamespace()));
}
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
-import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
@Before
public void setup() {
- foobarModule = QNameModule.create(URI.create("foobar-namespace"), Revision.of("2016-09-19"));
+ foobarModule = QNameModule.create(XMLNamespace.of("foobar-namespace"), Revision.of("2016-09-19"));
outerContainer = QName.create(foobarModule, "outer-container");
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
@Test
public void testWriteIdentityRef() throws Exception {
- final QNameModule parent = QNameModule.create(URI.create("parent:uri"), Revision.of("2000-01-01"));
+ final QNameModule parent = QNameModule.create(XMLNamespace.of("parent:uri"), Revision.of("2000-01-01"));
String xmlAsString = createXml(writer -> {
writer.writeStartElement("element");
import com.google.common.collect.ImmutableSet;
import java.io.IOException;
import java.io.InputStream;
-import java.net.URI;
import java.net.URISyntaxException;
import java.util.HashMap;
import java.util.Map;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
public class XmlToNormalizedNodesTest {
- private static final QNameModule FOO_MODULE = QNameModule.create(URI.create("foo-namespace"));
+ private static final QNameModule FOO_MODULE = QNameModule.create(XMLNamespace.of("foo-namespace"));
private static final QName PARENT_CONTAINER = QName.create(FOO_MODULE, "parent-container");
- private static final QNameModule BAZ_MODULE = QNameModule.create(URI.create("baz-namespace"));
+ private static final QNameModule BAZ_MODULE = QNameModule.create(XMLNamespace.of("baz-namespace"));
private static final QName OUTER_CONTAINER = QName.create(BAZ_MODULE, "outer-container");
private static final QName MY_CONTAINER_1 = QName.create(BAZ_MODULE, "my-container-1");
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
-import java.net.URI;
import java.util.Collection;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import org.opendaylight.yangtools.util.xml.UntrustedXML;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
@Before
public void setup() {
- fooModule = QNameModule.create(URI.create("foo-namespace"));
+ fooModule = QNameModule.create(XMLNamespace.of("foo-namespace"));
fooLeafContainer = QName.create(fooModule, "leaf-container");
fooIdentity = QName.create(fooModule, "ident-one");
new XMLTestCase() {}.assertXMLEqual(diff, true);
}
- private DOMResult convertNormalizedNodeToXml(NormalizedNode normalizedNode)
+ private DOMResult convertNormalizedNodeToXml(final NormalizedNode normalizedNode)
throws XMLStreamException, IOException {
final DOMResult domResult = new DOMResult(UntrustedXML.newDocumentBuilder().newDocument());
import static org.junit.Assert.fail;
import static org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodecTestHelper.getCodec;
-import java.net.URI;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.codec.StringCodec;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
"/string-pattern-checking-codec-test.yang");
assertNotNull(schemaContext);
- final QNameModule testModuleQName = QNameModule.create(URI.create("string-pattern-checking-codec-test"));
+ final QNameModule testModuleQName = QNameModule.create(XMLNamespace.of("string-pattern-checking-codec-test"));
final Module testModule = schemaContext.findModules("string-pattern-checking-codec-test").iterator().next();
final ContainerSchemaNode testContainer = (ContainerSchemaNode) testModule.findDataChildByName(
import static org.junit.Assert.assertTrue;
import com.google.common.collect.ImmutableList;
-import java.net.URI;
import java.util.Map;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
final Map<QName, LeafRefContext> referencingChilds = leafRefContext.getReferencingChilds();
assertEquals(7, referencingChilds.size());
- final QNameModule bazQNameModule = QNameModule.create(URI.create(BAZ_NS));
+ final QNameModule bazQNameModule = QNameModule.create(XMLNamespace.of(BAZ_NS));
final LeafRefPath expectedPathToBazTarget = LeafRefPath.create(true,
new QNameWithPredicateImpl(bazQNameModule, "root", ImmutableList.of()),
new QNameWithPredicateImpl(bazQNameModule, "target", ImmutableList.of()));
assertLeafRef(referencingChilds.get(bar("my-leafref-in-bar")), expectedPathToBazTarget);
assertLeafRef(referencingChilds.get(bar("my-leafref-in-bar-2")), expectedPathToBazTarget);
- final QNameModule barQNameModule = QNameModule.create(URI.create(BAR_NS));
+ final QNameModule barQNameModule = QNameModule.create(XMLNamespace.of(BAR_NS));
final LeafRefPath expectedPathToBarTarget = LeafRefPath.create(true,
new QNameWithPredicateImpl(barQNameModule, "bar-target", ImmutableList.of()));
assertLeafRef(referencingChilds.get(foo("direct-leafref")), expectedPathToBarTarget);
import com.google.common.collect.ImmutableSet;
import java.io.IOException;
-import java.net.URI;
-import java.net.URISyntaxException;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.HashMap;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
private DOMSource anyxmlDomSource;
@Before
- public void setup() throws URISyntaxException, ParseException {
- bazModule = QNameModule.create(new URI("baz-namespace"), Revision.of("1970-01-01"));
+ public void setup() throws ParseException {
+ bazModule = QNameModule.create(XMLNamespace.of("baz-namespace"), Revision.of("1970-01-01"));
outerContainer = QName.create(bazModule, "outer-container");
import com.google.common.collect.ImmutableSet;
import java.io.File;
-import java.net.URI;
import java.net.URISyntaxException;
import java.util.Collections;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
}
private static QName getQName(final String localName) {
- return QName.create(URI.create("namespace"), localName);
+ return QName.create(XMLNamespace.of("namespace"), localName);
}
private static NodeIdentifier getNodeIdentifier(final String localName) {
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMap.Builder;
-import java.net.URI;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
@Before
public void init() {
- foo = QNameModule.create(URI.create("foo"));
+ foo = QNameModule.create(XMLNamespace.of("foo"));
root = QName.create(foo, "root");
subRoot = QName.create(foo, "sub-root");
outerList = QName.create(foo, "outer-list");
import static org.junit.Assert.fail;
import com.google.common.collect.ImmutableMap;
-import java.net.URI;
import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
@Before
public void setup() {
- testModule = QNameModule.create(URI.create("ordered-list-modification-test"));
+ testModule = QNameModule.create(XMLNamespace.of("ordered-list-modification-test"));
parentContainer = QName.create(testModule, "parent-container");
childContainer = QName.create(testModule, "child-container");
parentOrderedList = QName.create(testModule, "parent-ordered-list");
import static com.google.common.base.Preconditions.checkArgument;
import com.google.common.base.Splitter;
-import java.net.URI;
import java.util.Iterator;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.concepts.AbstractIllegalArgumentCodec;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
abstract class AbstractNamespaceCodec<T> extends AbstractIllegalArgumentCodec<String, T> {
private static final Splitter COLON_SPLITTER = Splitter.on(':');
* @param namespace Namespace to map
* @return Allocated unique prefix, or null if the prefix cannot be mapped.
*/
- protected abstract @Nullable String prefixForNamespace(@NonNull URI namespace);
+ protected abstract @Nullable String prefixForNamespace(@NonNull XMLNamespace namespace);
/**
* Create a QName for a prefix and local name.
import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
-import java.net.URI;
import java.util.Iterator;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextProvider;
import org.opendaylight.yangtools.yang.model.api.Module;
}
@Override
- protected String prefixForNamespace(final URI namespace) {
+ protected String prefixForNamespace(final XMLNamespace namespace) {
final Iterator<? extends Module> modules = context.findModules(namespace).iterator();
return modules.hasNext() ? modules.next().getName() : null;
}
package org.opendaylight.yangtools.yang.data.util;
-import java.net.URI;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
* (where n is number of choices through it was passed)
*/
public static Deque<DataSchemaNode> findSchemaNodeByNameAndNamespace(final DataSchemaNode dataSchemaNode,
- final String childName, final URI namespace) {
+ final String childName, final XMLNamespace namespace) {
final Deque<DataSchemaNode> result = new ArrayDeque<>();
final List<ChoiceSchemaNode> childChoices = new ArrayList<>();
DataSchemaNode potentialChildNode = null;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
-import java.net.URI;
import java.util.Optional;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class DataSchemaContextTreeTest {
- private static final QNameModule MODULE = QNameModule.create(URI.create("dataschemacontext"));
+ private static final QNameModule MODULE = QNameModule.create(XMLNamespace.of("dataschemacontext"));
private static final QName FOO = QName.create(MODULE, "foo");
private static final QName BAR = QName.create(MODULE, "bar");
private static final QName BAZ = QName.create(MODULE, "baz");
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThrows;
-import java.net.URI;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class IdentityCodecUtilTest {
- private static final QNameModule MODULE = QNameModule.create(URI.create("yangtools846"));
+ private static final QNameModule MODULE = QNameModule.create(XMLNamespace.of("yangtools846"));
private static EffectiveModelContext SCHEMA_CONTEXT;
@BeforeClass
*/
package org.opendaylight.yangtools.yang.model.api;
-import java.net.URI;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
public interface QNameModuleAware {
/**
*/
@NonNull QNameModule getQNameModule();
- @Deprecated
- default @NonNull URI getNamespace() {
+ default @NonNull XMLNamespace getNamespace() {
return getQNameModule().getNamespace();
}
import com.google.common.annotations.Beta;
import com.google.common.collect.Collections2;
import com.google.common.collect.ImmutableSet;
-import java.net.URI;
import java.util.Collection;
import java.util.Collections;
import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.xpath.api.YangXPathExpression.QualifiedBound;
/**
* QName of NETCONF top-level data node.
*/
// FIXME: YANGTOOLS-1074: we do not want this name
- @NonNull QName NAME = QName.create(URI.create("urn:ietf:params:xml:ns:netconf:base:1.0"), "data").intern();
+ @NonNull QName NAME = QName.create(XMLNamespace.of("urn:ietf:params:xml:ns:netconf:base:1.0"), "data").intern();
/**
* Returns data schema node instances which represents direct subnodes (like
* @return module instance which has name and revision the same as are the values specified in parameters
* <code>namespace</code> and no revision.
*/
- default Optional<Module> findModule(final @NonNull URI namespace) {
+ default Optional<Module> findModule(final @NonNull XMLNamespace namespace) {
return findModule(QNameModule.create(namespace));
}
* @return module instance which has name and revision the same as are the values specified in parameters
* <code>namespace</code> and <code>revision</code>.
*/
- default Optional<Module> findModule(final @NonNull URI namespace, final @Nullable Revision revision) {
+ default Optional<Module> findModule(final @NonNull XMLNamespace namespace, final @Nullable Revision revision) {
return findModule(QNameModule.create(namespace, revision));
}
* @return module instance which has name and revision the same as are the values specified in parameters
* <code>namespace</code> and <code>revision</code>.
*/
- default Optional<Module> findModule(final @NonNull URI namespace, final @NonNull Optional<Revision> revision) {
+ default Optional<Module> findModule(final @NonNull XMLNamespace namespace,
+ final @NonNull Optional<Revision> revision) {
return findModule(QNameModule.create(namespace, revision));
}
* Returns module instances (from the context) with a concrete name. Returned Set is required to have its iteration
* order guarantee that the latest revision is encountered first.
*
- * @param name
- * string with the module name
+ * @param name string with the module name
* @return set of module instances with specified name.
*/
default @NonNull Collection<? extends @NonNull Module> findModules(final String name) {
* Returns module instance (from the context) with concrete namespace. Returned Set is required to have its
* iteration order guarantee that the latest revision is encountered first.
*
- * @param namespace
- * URI instance with specified namespace
- * @return module instance which has namespace equal to the
- * <code>namespace</code> or <code>null</code> in other cases
+ * @param namespace XMLNamespace instance with specified namespace
+ * @return module instance which has namespace equal to the {@code namespace} or {@code null} in other cases
*/
- default @NonNull Collection<? extends @NonNull Module> findModules(final URI namespace) {
+ default @NonNull Collection<? extends @NonNull Module> findModules(final XMLNamespace namespace) {
return Collections2.filter(getModules(), m -> namespace.equals(m.getNamespace()));
}
package org.opendaylight.yangtools.yang.model.api.stmt;
import com.google.common.annotations.Beta;
-import java.net.URI;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
@Beta
-public interface NamespaceEffectiveStatement extends EffectiveStatement<URI, NamespaceStatement> {
+public interface NamespaceEffectiveStatement extends EffectiveStatement<XMLNamespace, NamespaceStatement> {
@Override
default StatementDefinition statementDefinition() {
return YangStmtMapping.NAMESPACE;
*/
package org.opendaylight.yangtools.yang.model.api.stmt;
-import java.net.URI;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
-public interface NamespaceStatement extends DeclaredStatement<URI> {
+public interface NamespaceStatement extends DeclaredStatement<XMLNamespace> {
@Override
default StatementDefinition statementDefinition() {
return YangStmtMapping.NAMESPACE;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
-import java.net.URI;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
@BeforeClass
public static void beforeClass() {
context = YangParserTestUtils.parseYangResourceDirectory("/schema-context-util");
- myModule = context.findModule(URI.create("uri:my-module"), Revision.of("2014-10-07")).get();
+ myModule = context.findModule(XMLNamespace.of("uri:my-module"), Revision.of("2014-10-07")).get();
}
@Test
@Test
public void findDataSchemaNodeTest() {
- final Module importedModule = context.findModule(URI.create("uri:imported-module"),
+ final Module importedModule = context.findModule(XMLNamespace.of("uri:imported-module"),
Revision.of("2014-10-07")).get();
final SchemaNode testNode = ((ContainerSchemaNode) importedModule.getDataChildByName(QName.create(
import com.google.common.collect.SetMultimap;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
-import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
*
* @return Map of modules where key is namespace
*/
- protected abstract SetMultimap<URI, Module> getNamespaceToModules();
+ protected abstract SetMultimap<XMLNamespace, Module> getNamespaceToModules();
/**
* Returns the module name-to-module mapping.
}
@Override
- public Collection<? extends Module> findModules(final URI namespace) {
+ public Collection<? extends Module> findModules(final XMLNamespace namespace) {
return getNamespaceToModules().get(namespace);
}
import com.google.common.collect.Multimaps;
import com.google.common.collect.SetMultimap;
import com.google.common.collect.TreeMultimap;
-import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
import org.opendaylight.yangtools.yang.model.api.ModuleLike;
private final ImmutableSet<Module> filteredModules;
//collections to be filled in with filtered data
- private final ImmutableSetMultimap<URI, Module> namespaceToModules;
+ private final ImmutableSetMultimap<XMLNamespace, Module> namespaceToModules;
private final ImmutableSetMultimap<String, Module> nameToModules;
/**
sortedModules.sort(NAME_REVISION_COMPARATOR);
this.filteredModules = ImmutableSet.copyOf(sortedModules);
- final SetMultimap<URI, Module> nsMap = Multimaps.newSetMultimap(new TreeMap<>(),
+ final SetMultimap<XMLNamespace, Module> nsMap = Multimaps.newSetMultimap(new TreeMap<>(),
AbstractSchemaContext::createModuleSet);
final SetMultimap<String, Module> nameMap = Multimaps.newSetMultimap(new TreeMap<>(),
AbstractSchemaContext::createModuleSet);
}
@Override
- protected SetMultimap<URI, Module> getNamespaceToModules() {
+ protected SetMultimap<XMLNamespace, Module> getNamespaceToModules() {
return namespaceToModules;
}
import com.google.common.collect.HashBasedTable;
import com.google.common.collect.Lists;
import com.google.common.collect.Table;
-import java.net.URI;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import org.opendaylight.yangtools.util.TopologicalSort.Node;
import org.opendaylight.yangtools.util.TopologicalSort.NodeImpl;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
*/
private static void processDependencies(final Table<String, Optional<Revision>, ModuleNodeImpl> moduleGraph,
final Collection<? extends Module> mmbs) {
- final Map<URI, Module> allNS = new HashMap<>();
+ final Map<XMLNamespace, Module> allNS = new HashMap<>();
// Create edges in graph
for (final Module module : mmbs) {
final Map<String, Optional<Revision>> imported = new HashMap<>();
final String fromName = module.getName();
- final URI ns = module.getNamespace();
+ final XMLNamespace ns = module.getNamespace();
final Optional<Revision> fromRevision = module.getRevision();
// check for existence of module with same namespace
return false;
}
final ModuleNodeImpl other = (ModuleNodeImpl) obj;
- if (name == null) {
- if (other.name != null) {
- return false;
- }
- } else if (!name.equals(other.name)) {
+ if (!Objects.equals(name, other.name)) {
return false;
}
- if (revision == null) {
- if (other.revision != null) {
- return false;
- }
- } else if (!revision.equals(other.revision)) {
+ if (!Objects.equals(revision, other.revision)) {
return false;
}
return true;
import com.google.common.collect.ImmutableSetMultimap;
import com.google.common.collect.Multimaps;
import com.google.common.collect.SetMultimap;
-import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.opendaylight.yangtools.rfc7952.model.api.AnnotationSchemaNodeAwareSchemaContext;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.Module;
/**
*/
@Beta
public class SimpleSchemaContext extends AbstractSchemaContext implements AnnotationSchemaNodeAwareSchemaContext {
- private final ImmutableSetMultimap<URI, Module> namespaceToModules;
+ private final ImmutableSetMultimap<XMLNamespace, Module> namespaceToModules;
private final ImmutableSetMultimap<String, Module> nameToModules;
private final ImmutableMap<QNameModule, Module> moduleMap;
private final ImmutableSet<Module> modules;
*
* Invest some quality time in building up lookup tables for both.
*/
- final SetMultimap<URI, Module> nsMap = Multimaps.newSetMultimap(new TreeMap<>(),
+ final SetMultimap<XMLNamespace, Module> nsMap = Multimaps.newSetMultimap(new TreeMap<>(),
AbstractSchemaContext::createModuleSet);
final SetMultimap<String, Module> nameMap = Multimaps.newSetMultimap(new TreeMap<>(),
AbstractSchemaContext::createModuleSet);
}
@Override
- protected final SetMultimap<URI, Module> getNamespaceToModules() {
+ protected final SetMultimap<XMLNamespace, Module> getNamespaceToModules() {
return namespaceToModules;
}
import static org.mockito.Mockito.doReturn;
import com.google.common.collect.ImmutableSet;
-import java.net.URI;
import java.util.List;
import java.util.Optional;
import org.junit.Before;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
@RunWith(MockitoJUnitRunner.class)
public class ModuleDependencySortTest {
- public static final QNameModule FOO_MODULE = QNameModule.create(URI.create("foo"));
- public static final QNameModule BAR_MODULE = QNameModule.create(URI.create("bar"));
+ public static final QNameModule FOO_MODULE = QNameModule.create(XMLNamespace.of("foo"));
+ public static final QNameModule BAR_MODULE = QNameModule.create(XMLNamespace.of("bar"));
@Mock
public Module fooNoRev;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
private static void mockModuleLike(final ModuleLike mockedModule, final String name) {
doReturn(name).when(mockedModule).getName();
doReturn(Optional.of(REVISION)).when(mockedModule).getRevision();
- final URI newNamespace = URI.create(NAMESPACE.toString() + ":" + name);
+ final XMLNamespace newNamespace = XMLNamespace.of(NAMESPACE.toString() + ":" + name);
doReturn(newNamespace).when(mockedModule).getNamespace();
doReturn(QNameModule.create(newNamespace, REVISION)).when(mockedModule).getQNameModule();
doReturn(new HashSet<>()).when(mockedModule).getSubmodules();
import com.google.common.base.Splitter;
import com.google.common.collect.ImmutableList;
-import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.PathExpression;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class SchemaContextUtilTest {
public static final Splitter SPACE_SPLITTER = Splitter.on(' ');
- public static final URI NAMESPACE = URI.create("abc");
+ public static final XMLNamespace NAMESPACE = XMLNamespace.of("abc");
@Mock
public SchemaContext mockSchemaContext;
@Test
public void findDataSchemaNodeIllegalArgumentTest2() {
assertThrows(NullPointerException.class, () -> SchemaContextUtil.findDataSchemaNode(null,
- SchemaPath.create(true, QName.create(URI.create("uri:my-module"), Revision.of("2014-10-07"), "foo"))));
+ SchemaPath.create(true, QName.create(XMLNamespace.of("uri:my-module"), Revision.of("2014-10-07"), "foo"))));
}
@Test
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
-import java.net.URI;
import java.util.Collection;
import java.util.List;
import java.util.Optional;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.Module;
public class SimpleSchemaContextTest {
assertFindModules(expected, "foo", foo2, foo0, foo1);
assertFindModules(expected, "foo", foo2, foo1, foo0);
- final URI uri = URI.create("foo");
+ final XMLNamespace uri = XMLNamespace.of("foo");
assertFindModules(expected, uri, foo0, foo1, foo2);
assertFindModules(expected, uri, foo0, foo2, foo1);
assertFindModules(expected, uri, foo1, foo0, foo2);
assertArrayEquals(expected.toArray(), actual.toArray());
}
- private static void assertFindModules(final List<Module> expected, final URI uri, final Module... modules) {
+ private static void assertFindModules(final List<Module> expected, final XMLNamespace uri,
+ final Module... modules) {
final Collection<? extends Module> actual = SimpleSchemaContext.forModules(ImmutableSet.copyOf(modules))
.findModules(uri);
assertArrayEquals(expected.toArray(), actual.toArray());
}
private static Module mockModule(final String name, final Optional<Revision> revision) {
- final QNameModule mod = QNameModule.create(URI.create(name), revision);
+ final QNameModule mod = QNameModule.create(XMLNamespace.of(name), revision);
final Module ret = mock(Module.class);
doReturn(name).when(ret).getName();
doReturn(mod.getNamespace()).when(ret).getNamespace();
import com.google.common.collect.ImmutableSetMultimap;
import com.google.common.collect.SetMultimap;
import com.google.common.util.concurrent.ListenableFuture;
-import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import java.util.concurrent.ExecutionException;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
private static final String FOOBAR = "/bug9195/foobar.yang";
private static final String BAR_INVALID = "/bug9195/bar-invalid.yang";
private static final String BAZ_INVALID = "/bug9195/baz-invalid.yang";
- private static final URI FOO_NS = URI.create("foo-ns");
- private static final URI BAR_NS = URI.create("bar-ns");
- private static final URI BAZ_NS = URI.create("baz-ns");
+ private static final XMLNamespace FOO_NS = XMLNamespace.of("foo-ns");
+ private static final XMLNamespace BAR_NS = XMLNamespace.of("bar-ns");
+ private static final XMLNamespace BAZ_NS = XMLNamespace.of("baz-ns");
private static final Revision REVISION = Revision.of("2017-05-16");
private static final QNameModule FOO_MODULE = QNameModule.create(FOO_NS, REVISION);
private static final QName MY_FOO_CONT_A = QName.create(FOO_MODULE, "my-foo-cont-a");
import com.google.common.collect.HashMultimap;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Multimap;
-import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import org.opendaylight.yangtools.concepts.Mutable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
private PrefixToModule preLinkagePrefixes() {
final PrefixToModuleMap preLinkagePrefixes = new PrefixToModuleMap();
- final Map<String, URI> prefixToNamespaceMap = getAllFromLocalStorage(ImpPrefixToNamespace.class);
+ final Map<String, XMLNamespace> prefixToNamespaceMap = getAllFromLocalStorage(ImpPrefixToNamespace.class);
if (prefixToNamespaceMap == null) {
//:FIXME if it is a submodule without any import, the map is null. Handle also submodules and includes...
return null;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
-import java.net.URI;
-import java.net.URISyntaxException;
import java.util.Optional;
import javax.xml.transform.TransformerException;
import org.opendaylight.yangtools.concepts.AbstractSimpleIdentifiable;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.meta.ArgumentDefinition;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
public final class YinStatementStreamSource extends AbstractSimpleIdentifiable<SourceIdentifier>
implements StatementStreamSource {
private static final Logger LOG = LoggerFactory.getLogger(YinStatementStreamSource.class);
- private static final LoadingCache<String, URI> URI_CACHE = CacheBuilder.newBuilder().weakValues().build(
- new CacheLoader<String, URI>() {
+ private static final LoadingCache<String, XMLNamespace> NS_CACHE = CacheBuilder.newBuilder().weakValues().build(
+ new CacheLoader<String, XMLNamespace>() {
@Override
- public URI load(final String key) throws URISyntaxException {
- return new URI(key);
+ public XMLNamespace load(final String key) {
+ return XMLNamespace.of(key).intern();
}
});
private final Node root;
private static StatementDefinition getValidDefinition(final Node node, final StatementWriter writer,
final QNameToStatementDefinition stmtDef, final StatementSourceReference ref) {
- final URI uri = URI_CACHE.getUnchecked(node.getNamespaceURI());
+ final XMLNamespace uri = NS_CACHE.getUnchecked(node.getNamespaceURI());
final StatementDefinition def = stmtDef.getByNamespaceAndLocalName(uri, node.getLocalName());
if (def == null) {
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
-import java.net.URI;
import java.util.Collection;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.openconfig.model.api.OpenConfigStatements;
import org.opendaylight.yangtools.yang.common.Empty;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
public void apply(final InferenceContext ctx) {
final StmtContext<?, ?, ?> importedModuleContext = imported.resolve(ctx);
verify(moduleName.equals(importedModuleContext.getRawArgument()));
- final URI importedModuleNamespace = verifyNotNull(
+ final XMLNamespace importedModuleNamespace = verifyNotNull(
importedModuleContext.getFromNamespace(ModuleNameToNamespace.class, moduleName));
final String impPrefix = SourceException.throwIfNull(
firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class), stmt,
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
-import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.Submodule;
public void onPreLinkageDeclared(final Mutable<UnqualifiedQName, ModuleStatement, ModuleEffectiveStatement> stmt) {
final String moduleName = stmt.getRawArgument();
- final URI moduleNs = SourceException.throwIfNull(
+ final XMLNamespace moduleNs = SourceException.throwIfNull(
firstAttributeOf(stmt.declaredSubstatements(), NamespaceStatement.class), stmt,
"Namespace of the module [%s] is missing", moduleName);
stmt.addToNs(ModuleNameToNamespace.class, moduleName, moduleNs);
@Override
public void onLinkageDeclared(final Mutable<UnqualifiedQName, ModuleStatement, ModuleEffectiveStatement> stmt) {
- final URI moduleNs = SourceException.throwIfNull(
+ final XMLNamespace moduleNs = SourceException.throwIfNull(
firstAttributeOf(stmt.declaredSubstatements(), NamespaceStatement.class), stmt,
"Namespace of the module [%s] is missing", stmt.argument());
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.namespace;
-import java.net.URI;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement.DefaultArgument;
-final class EmptyNamespaceEffectiveStatement extends DefaultArgument<URI, NamespaceStatement>
+final class EmptyNamespaceEffectiveStatement extends DefaultArgument<XMLNamespace, NamespaceStatement>
implements NamespaceEffectiveStatement {
EmptyNamespaceEffectiveStatement(final NamespaceStatement declared) {
super(declared);
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.namespace;
-import java.net.URI;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.ArgumentToString;
-final class EmptyNamespaceStatement extends ArgumentToString<URI> implements NamespaceStatement {
- EmptyNamespaceStatement(final URI argument) {
+final class EmptyNamespaceStatement extends ArgumentToString<XMLNamespace> implements NamespaceStatement {
+ EmptyNamespaceStatement(final XMLNamespace argument) {
super(argument);
}
}
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.namespace;
import com.google.common.collect.ImmutableList;
-import java.net.URI;
-import java.net.URISyntaxException;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
public final class NamespaceStatementSupport
- extends AbstractStatementSupport<URI, NamespaceStatement, NamespaceEffectiveStatement> {
+ extends AbstractStatementSupport<XMLNamespace, NamespaceStatement, NamespaceEffectiveStatement> {
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator.builder(YangStmtMapping
.NAMESPACE)
.build();
}
@Override
- public URI parseArgumentValue(final StmtContext<?, ?,?> ctx, final String value) {
+ public XMLNamespace parseArgumentValue(final StmtContext<?, ?,?> ctx, final String value) {
try {
- return new URI(value);
- } catch (URISyntaxException e) {
+ return XMLNamespace.of(value).intern();
+ } catch (IllegalArgumentException e) {
throw new SourceException(ctx, e, "Invalid namespace \"%s\"", value);
}
}
}
@Override
- protected NamespaceStatement createDeclared(@NonNull final StmtContext<URI, NamespaceStatement, ?> ctx,
+ protected NamespaceStatement createDeclared(@NonNull final StmtContext<XMLNamespace, NamespaceStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
return new RegularNamespaceStatement(ctx.getArgument(), substatements);
}
@Override
- protected NamespaceStatement createEmptyDeclared(final StmtContext<URI, NamespaceStatement, ?> ctx) {
+ protected NamespaceStatement createEmptyDeclared(final StmtContext<XMLNamespace, NamespaceStatement, ?> ctx) {
return new EmptyNamespaceStatement(ctx.getArgument());
}
@Override
- protected NamespaceEffectiveStatement createEffective(final Current<URI, NamespaceStatement> stmt,
+ protected NamespaceEffectiveStatement createEffective(final Current<XMLNamespace, NamespaceStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return substatements.isEmpty() ? new EmptyNamespaceEffectiveStatement(stmt.declared())
: new RegularNamespaceEffectiveStatement(stmt.declared(), substatements);
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.namespace;
import com.google.common.collect.ImmutableList;
-import java.net.URI;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements;
-final class RegularNamespaceEffectiveStatement extends WithSubstatements<URI, NamespaceStatement>
+final class RegularNamespaceEffectiveStatement extends WithSubstatements<XMLNamespace, NamespaceStatement>
implements NamespaceEffectiveStatement {
RegularNamespaceEffectiveStatement(final NamespaceStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.namespace;
import com.google.common.collect.ImmutableList;
-import java.net.URI;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.ArgumentToString.WithSubstatements;
-final class RegularNamespaceStatement extends WithSubstatements<URI> implements NamespaceStatement {
- RegularNamespaceStatement(final URI argument,
+final class RegularNamespaceStatement extends WithSubstatements<XMLNamespace> implements NamespaceStatement {
+ RegularNamespaceStatement(final XMLNamespace argument,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
super(argument, substatements);
}
import static org.junit.Assert.assertTrue;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
-import java.net.URI;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
private static final StatementStreamSource AUGMENTED = sourceForResource("/stmt-test/augments/augmented.yang");
private static final StatementStreamSource ROOT = sourceForResource("/stmt-test/augments/aug-root.yang");
- private static final QNameModule ROOT_QNAME_MODULE = QNameModule.create(URI.create("root"));
- private static final QNameModule AUGMENTED_QNAME_MODULE = QNameModule.create(URI.create("aug"));
+ private static final QNameModule ROOT_QNAME_MODULE = QNameModule.create(XMLNamespace.of("root"));
+ private static final QNameModule AUGMENTED_QNAME_MODULE = QNameModule.create(XMLNamespace.of("aug"));
private final QName augParent1 = QName.create(AUGMENTED_QNAME_MODULE,
"aug-parent1");
import static org.junit.Assert.assertTrue;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.assertPathEquals;
-import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
public class AugmentTest {
private static final QNameModule FOO = QNameModule.create(
- URI.create("urn:opendaylight.foo"), Revision.of("2013-10-13"));
+ XMLNamespace.of("urn:opendaylight.foo"), Revision.of("2013-10-13"));
private static final QNameModule BAR = QNameModule.create(
- URI.create("urn:opendaylight.bar"), Revision.of("2013-10-14"));
+ XMLNamespace.of("urn:opendaylight.bar"), Revision.of("2013-10-14"));
private static final QNameModule BAZ = QNameModule.create(
- URI.create("urn:opendaylight.baz"), Revision.of("2013-10-15"));
+ XMLNamespace.of("urn:opendaylight.baz"), Revision.of("2013-10-15"));
private static final QName Q0 = QName.create(BAR, "interfaces");
private static final QName Q1 = QName.create(BAR, "ifEntry");
@Test
public void testAugmentRpc() throws Exception {
final SchemaContext context = TestUtils.loadModules(getClass().getResource("/augment-test/rpc").toURI());
- final URI NS_BAR = URI.create("urn:opendaylight:bar");
- final URI NS_FOO = URI.create("urn:opendaylight:foo");
+ final XMLNamespace NS_BAR = XMLNamespace.of("urn:opendaylight:bar");
+ final XMLNamespace NS_FOO = XMLNamespace.of("urn:opendaylight:foo");
final Revision revision = Revision.of("2013-10-11");
final Module bar = TestUtils.findModule(context, "bar").get();
final Collection<? extends RpcDefinition> rpcs = bar.getRpcs();
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import java.net.URI;
import java.util.Collection;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedStatement;
assertEquals(1, unknownNodes.size());
final UnrecognizedStatement action = unknownNodes.iterator().next();
- final QNameModule qm = QNameModule.create(URI.create("urn:test:bug1412"), Revision.of("2014-07-25"));
+ final QNameModule qm = QNameModule.create(XMLNamespace.of("urn:test:bug1412"), Revision.of("2014-07-25"));
QName expectedNodeType = QName.create("urn:test:bug1412:ext:definitions", "2014-07-25", "action");
assertEquals(expectedNodeType, action.statementDefinition().getStatementName());
assertEquals("hello", action.argument());
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
final SchemaContext schema = StmtTestUtils.parseYangSources("/bugs/bug2872");
assertNotNull(schema);
- final QNameModule bug2872module = QNameModule.create(URI.create("bug2872"), Revision.of("2016-06-08"));
+ final QNameModule bug2872module = QNameModule.create(XMLNamespace.of("bug2872"), Revision.of("2016-06-08"));
final QName foo = QName.create(bug2872module, "bar");
final DataSchemaNode dataSchemaNode = schema.getDataChildByName(foo);
import static org.junit.Assert.assertNotNull;
-import java.net.URI;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
assertNotNull(context);
- QNameModule foo = QNameModule.create(new URI("foo"), Revision.of("2015-09-02"));
+ QNameModule foo = QNameModule.create(XMLNamespace.of("foo"), Revision.of("2015-09-02"));
SchemaPath targetPath = SchemaPath
.create(true, QName.create(foo, "augment-target"))
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.fail;
-import java.net.URI;
import java.util.Collection;
import java.util.Set;
import org.junit.Test;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
SchemaContext schema = StmtTestUtils.parseYangSources("/bugs/bug4456");
assertNotNull(schema);
- Set<Module> modules = (Set<Module>) schema.findModules(URI.create("foo"));
+ Set<Module> modules = (Set<Module>) schema.findModules(XMLNamespace.of("foo"));
assertEquals(1, modules.size());
Module moduleFoo = modules.iterator().next();
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
-import java.net.URI;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug4610");
Revision revision = Revision.of("2015-12-12");
- QNameModule foo = QNameModule.create(URI.create("foo"), revision);
- QNameModule bar = QNameModule.create(URI.create("bar"), revision);
+ QNameModule foo = QNameModule.create(XMLNamespace.of("foo"), revision);
+ QNameModule bar = QNameModule.create(XMLNamespace.of("bar"), revision);
QName g1 = QName.create(bar, "g1");
QName g2 = QName.create(bar, "g2");
import com.google.common.collect.Range;
import java.io.File;
-import java.net.URI;
import java.util.Collection;
import java.util.List;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
final SchemaContext schemaContext = TestUtils.parseYangSources(extdef, stringWithExt);
final LeafSchemaNode leaf = (LeafSchemaNode) typesModule(schemaContext).getDataChildByName(
- QName.create(URI.create("urn:custom.types.demo"), "leaf-length-pattern-unknown"));
+ QName.create(XMLNamespace.of("urn:custom.types.demo"), "leaf-length-pattern-unknown"));
// then
final TypeDefinition<?> type = leaf.getType();
final SchemaContext schemaContext = TestUtils.parseYangSources(extdef, stringWithExt);
final LeafSchemaNode leaf = (LeafSchemaNode) typesModule(schemaContext).getDataChildByName(
- QName.create(URI.create("urn:custom.types.demo"), "leaf-length-unknown-pattern"));
+ QName.create(XMLNamespace.of("urn:custom.types.demo"), "leaf-length-unknown-pattern"));
// then
assertNotNull(leaf);
final SchemaContext schemaContext = TestUtils.parseYangSources(extdef, stringWithExt);
final LeafSchemaNode leaf = (LeafSchemaNode) typesModule(schemaContext).getDataChildByName(
- QName.create(URI.create("urn:custom.types.demo"), "leaf-unknown-length-pattern"));
+ QName.create(XMLNamespace.of("urn:custom.types.demo"), "leaf-unknown-length-pattern"));
// then
assertNotNull(leaf);
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
-import java.net.URI;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
@Test
public void unknownNodeTest() throws Exception {
final ModuleStatement bar = StmtTestUtils.parseYangSources("/bugs/bug7038")
- .getModuleStatement(QNameModule.create(URI.create("bar"))).getDeclared();
+ .getModuleStatement(QNameModule.create(XMLNamespace.of("bar"))).getDeclared();
final UnrecognizedStatement decimal64 = bar.findFirstDeclaredSubstatement(UnrecognizedStatement.class)
.orElseThrow();
assertEquals("decimal64", decimal64.argument());
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import java.net.URI;
import java.util.Collection;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.Submodule;
final Collection<? extends Module> modules = context.getModules();
assertEquals(8, modules.size());
- assertNotNull(context.findModule(new URI("foo-imp"), Revision.of("2017-01-23")));
- assertEquals(1, context.findModules(new URI("foo-imp-2")).size());
- assertEquals(1, context.findModules(new URI("foo-imp-imp")).size());
- assertEquals(1, context.findModules(new URI("bar")).size());
- assertEquals(1, context.findModules(new URI("baz")).size());
- assertTrue(context.findModule(new URI("baz-imp"), Revision.of("2002-01-01")).isPresent());
- final Collection<? extends Module> foo = context.findModules(new URI("foo"));
+ assertNotNull(context.findModule(XMLNamespace.of("foo-imp"), Revision.of("2017-01-23")));
+ assertEquals(1, context.findModules(XMLNamespace.of("foo-imp-2")).size());
+ assertEquals(1, context.findModules(XMLNamespace.of("foo-imp-imp")).size());
+ assertEquals(1, context.findModules(XMLNamespace.of("bar")).size());
+ assertEquals(1, context.findModules(XMLNamespace.of("baz")).size());
+ assertTrue(context.findModule(XMLNamespace.of("baz-imp"), Revision.of("2002-01-01")).isPresent());
+ final Collection<? extends Module> foo = context.findModules(XMLNamespace.of("foo"));
assertEquals(1, foo.size());
final Collection<? extends Submodule> subFoos = foo.iterator().next().getSubmodules();
assertEquals(1, subFoos.size());
- final Module parentMod = context.findModule(new URI("parent-mod-ns"), Revision.of("2017-09-07")).get();
+ final Module parentMod = context.findModule(XMLNamespace.of("parent-mod-ns"), Revision.of("2017-09-07")).get();
assertEquals(1, parentMod.getSubmodules().size());
}
import com.google.common.collect.ImmutableSetMultimap;
import com.google.common.collect.SetMultimap;
-import java.net.URI;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
private static final StatementStreamSource BAR_INVALID_MODULE = sourceForResource("/bugs/bug8307/bar-invalid.yang");
private static final StatementStreamSource BAZ_INVALID_MODULE = sourceForResource("/bugs/bug8307/baz-invalid.yang");
- private static final URI FOO_NS = URI.create("foo-ns");
- private static final URI BAR_NS = URI.create("bar-ns");
- private static final URI BAZ_NS = URI.create("baz-ns");
+ private static final XMLNamespace FOO_NS = XMLNamespace.of("foo-ns");
+ private static final XMLNamespace BAR_NS = XMLNamespace.of("bar-ns");
+ private static final XMLNamespace BAZ_NS = XMLNamespace.of("baz-ns");
private static final Revision REVISION = Revision.of("2017-05-16");
private static final QNameModule FOO = QNameModule.create(FOO_NS, REVISION);
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThrows;
-import java.net.URI;
import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
rootBar = schema.findModule("bar", rev).get();
assertNotNull(rootFoo);
assertNotNull(rootBar);
- qnameFoo = QNameModule.create(URI.create("foo"), rev);
- qnameBar = QNameModule.create(URI.create("bar"), rev);
+ qnameFoo = QNameModule.create(XMLNamespace.of("foo"), rev);
+ qnameBar = QNameModule.create(XMLNamespace.of("bar"), rev);
assertNotNull(qnameFoo);
assertNotNull(qnameBar);
}
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
import java.io.FileNotFoundException;
-import java.net.URI;
import java.net.URISyntaxException;
import java.util.Collection;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
private static final StatementStreamSource SIMPLE_MODULE = sourceForResource(
"/stmt-test/effective-build/simple-module.yang");
- private static final QNameModule SIMPLE_MODULE_QNAME = QNameModule.create(URI.create("simple.yang"));
+ private static final QNameModule SIMPLE_MODULE_QNAME = QNameModule.create(XMLNamespace.of("simple.yang"));
private static final StatementStreamSource YANG_EXT = sourceForResource(
"/stmt-test/extensions/yang-ext.yang");
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.assertPathEquals;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
-import java.net.URI;
import java.util.Collection;
import java.util.Optional;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
private static final StatementStreamSource SUBMODULE = sourceForResource(
"/semantic-statement-parser/effective-module/submod.yang");
- private static final QNameModule ROOT_MODULE_QNAME = QNameModule.create(URI.create("root-ns"));
+ private static final QNameModule ROOT_MODULE_QNAME = QNameModule.create(XMLNamespace.of("root-ns"));
private static final QName CONT = QName.create(ROOT_MODULE_QNAME, "cont");
private static final QName FEATURE1 = QName.create(ROOT_MODULE_QNAME, "feature1");
assertEquals(1, deviations.size());
final Deviation deviationStmt = deviations.iterator().next();
assertNotNull(deviationStmt);
- final QNameModule importedModuleQName = QNameModule.create(URI.create("imported"), REVISION);
+ final QNameModule importedModuleQName = QNameModule.create(XMLNamespace.of("imported"), REVISION);
final QName importedContQName = QName.create(importedModuleQName, "cont");
assertEquals(Absolute.of(importedContQName), deviationStmt.getTargetPath());
assertEquals(DeviateKind.ADD, deviationStmt.getDeviates().iterator().next().getDeviateType());
import static org.junit.Assert.assertNotNull;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
-import java.net.URI;
import java.util.Collection;
import java.util.Optional;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
private static final StatementStreamSource SUBMODULE_TO_SUBMODULE_1 = sourceForResource(
"/stmt-test/submodules/submodule-to-submodule-1.yang");
- private static final QNameModule ROOT = QNameModule.create(URI.create("root-module"));
+ private static final QNameModule ROOT = QNameModule.create(XMLNamespace.of("root-module"));
@Test
public void modulesAndSubmodulesSimpleReferencesTest() throws ReactorException {
private static void findModulesSubTest(final SchemaContext result, final Module root, final Module imported) {
final Module foundRoot = result.findModule("root-module").get();
- final Collection<? extends Module> foundRoots = result.findModules(URI.create("root-module"));
- final Module foundRoot3 = result.findModule(URI.create("root-module")).get();
+ final Collection<? extends Module> foundRoots = result.findModules(XMLNamespace.of("root-module"));
+ final Module foundRoot3 = result.findModule(XMLNamespace.of("root-module")).get();
assertNotNull(foundRoot);
assertNotNull(foundRoots);
assertEquals(root, foundRoot3);
final Module foundImported = result.findModule("imported-module").get();
- final Collection<? extends Module> foundImporteds = result.findModules(URI.create("imported-module"));
- final Module foundImported3 = result.findModule(URI.create("imported-module")).get();
+ final Collection<? extends Module> foundImporteds = result.findModules(XMLNamespace.of("imported-module"));
+ final Module foundImported3 = result.findModule(XMLNamespace.of("imported-module")).get();
assertNotNull(foundImported);
assertNotNull(foundImporteds);
import static org.junit.Assert.assertTrue;
import java.io.IOException;
-import java.net.URI;
import java.net.URISyntaxException;
import java.text.ParseException;
import java.util.Collection;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
import org.opendaylight.yangtools.yang.model.api.Module;
assertNull(schemaContext.dataChildByName(QName.create("foo-namespace", "2016-09-21", "foo-cont")));
assertFalse(schemaContext.findModule("foo", Revision.of("2016-08-21")).isPresent());
- assertFalse(schemaContext.findModule(URI.create("foo-namespace"), Revision.of("2016-08-21")).isPresent());
+ assertFalse(schemaContext.findModule(XMLNamespace.of("foo-namespace"), Revision.of("2016-08-21")).isPresent());
assertFalse(schemaContext.isAugmenting());
assertFalse(schemaContext.isAddedByUses());
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.assertPathEquals;
import java.io.IOException;
-import java.net.URI;
import java.text.ParseException;
import java.util.Collection;
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
assertNotNull(gz);
assertNotNull(gzz);
- final QNameModule expectedModule = QNameModule.create(URI.create("urn:grouping:cascade-uses"),
+ final QNameModule expectedModule = QNameModule.create(XMLNamespace.of("urn:grouping:cascade-uses"),
Revision.of("2013-07-18"));
// grouping-U
import static org.junit.Assert.assertTrue;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
-import java.net.URI;
import java.util.Collection;
import java.util.Optional;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
}
private static void checkContentFullTest(final SchemaContext context) {
- URI yangTypesNS = URI.create("urn:ietf:params:xml:ns:yang:ietf-yang-types");
+ final XMLNamespace yangTypesNS = XMLNamespace.of("urn:ietf:params:xml:ns:yang:ietf-yang-types");
final Revision rev20100924 = Revision.of("2010-09-24");
final Revision rev20130516 = Revision.of("2013-05-16");
}
private static void checkContentSimpleTest(final SchemaContext context) {
- URI yangTypesNS = URI.create("urn:ietf:params:xml:ns:yang:ietf-yang-types");
+ final XMLNamespace yangTypesNS = XMLNamespace.of("urn:ietf:params:xml:ns:yang:ietf-yang-types");
final Revision rev20100924 = Revision.of("2010-09-24");
final Revision rev20130516 = Revision.of("2013-05-16");
private static void checkInterfacesModuleSimpleTest(final SchemaContext context,
final Revision rev20100924, final QName dateTimeTypeDef20100924) {
- URI interfacesNS = URI.create("urn:ietf:params:xml:ns:yang:ietf-interfaces");
+ XMLNamespace interfacesNS = XMLNamespace.of("urn:ietf:params:xml:ns:yang:ietf-interfaces");
Revision rev20121115 = Revision.of("2012-11-15");
final QNameModule interfacesNS20121115 = QNameModule.create(interfacesNS, rev20121115);
QName lastChange = QName.create(interfacesNS20121115, "last-change");
private static void checkNetconfMonitoringModuleSimpleTest(final SchemaContext context,
final Revision rev20130715, final QName dateTimeTypeDef20130715) {
- URI monitoringNS = URI.create("urn:ietf:params:xml:ns:yang:ietf-netconf-monitoring");
+ final XMLNamespace monitoringNS = XMLNamespace.of("urn:ietf:params:xml:ns:yang:ietf-netconf-monitoring");
final QNameModule monitoring19700101 = QNameModule.create(monitoringNS);
QName lockedTime = QName.create(monitoring19700101, "locked-time");
import com.google.common.collect.Iterables;
import com.google.common.collect.Range;
-import java.net.URI;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.Uint32;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
assertEquals(Status.CURRENT, testedType.getStatus());
QName testedTypeQName = testedType.getQName();
- assertEquals(URI.create("urn:ietf:params:xml:ns:yang:iana-timezones"), testedTypeQName.getNamespace());
+ assertEquals(XMLNamespace.of("urn:ietf:params:xml:ns:yang:iana-timezones"), testedTypeQName.getNamespace());
assertEquals(Revision.ofNullable("2012-07-09"), testedTypeQName.getRevision());
assertEquals("iana-timezone", testedTypeQName.getLocalName());
assertEquals("^(?:\\d*(\\.\\d*){1,127})$", pattern.getJavaPatternString());
QName testedTypeQName = testedType.getQName();
- assertEquals(URI.create("urn:ietf:params:xml:ns:yang:ietf-yang-types"), testedTypeQName.getNamespace());
+ assertEquals(XMLNamespace.of("urn:ietf:params:xml:ns:yang:ietf-yang-types"), testedTypeQName.getNamespace());
assertEquals(Revision.ofNullable("2010-09-24"), testedTypeQName.getRevision());
assertEquals("object-identifier-128", testedTypeQName.getLocalName());
pattern.getJavaPatternString());
QName testedTypeBaseQName = testedTypeBase.getQName();
- assertEquals(URI.create("urn:ietf:params:xml:ns:yang:ietf-yang-types"), testedTypeBaseQName.getNamespace());
+ assertEquals(XMLNamespace.of("urn:ietf:params:xml:ns:yang:ietf-yang-types"),
+ testedTypeBaseQName.getNamespace());
assertEquals(Revision.ofNullable("2010-09-24"), testedTypeBaseQName.getRevision());
assertEquals("object-identifier", testedTypeBaseQName.getLocalName());
}
TypeDefinition<?> testedType = TestUtils.findTypedef(typedefs, "service-type-ref");
IdentityrefTypeDefinition baseType = (IdentityrefTypeDefinition) testedType.getBaseType();
QName identity = baseType.getIdentities().iterator().next().getQName();
- assertEquals(URI.create("urn:custom.types.demo"), identity.getNamespace());
+ assertEquals(XMLNamespace.of("urn:custom.types.demo"), identity.getNamespace());
assertEquals(Revision.ofNullable("2012-04-16"), identity.getRevision());
assertEquals("service-type", identity.getLocalName());
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.assertPathEquals;
import java.io.IOException;
-import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayDeque;
import java.util.Collection;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
public class UsesAugmentTest {
private static final QNameModule UG = QNameModule.create(
- URI.create("urn:opendaylight:params:xml:ns:yang:uses-grouping"), Revision.of("2013-07-30"));
+ XMLNamespace.of("urn:opendaylight:params:xml:ns:yang:uses-grouping"), Revision.of("2013-07-30"));
private static final QNameModule GD = QNameModule.create(
- URI.create("urn:opendaylight:params:xml:ns:yang:grouping-definitions"), Revision.of("2013-09-04"));
+ XMLNamespace.of("urn:opendaylight:params:xml:ns:yang:grouping-definitions"), Revision.of("2013-09-04"));
private SchemaContext context;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertSame;
-import java.net.URI;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.stmt.GroupingEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.KeyEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ListEffectiveStatement;
@Test
public void testKeyStatementReuse() throws Exception {
final ModuleEffectiveStatement module = StmtTestUtils.parseYangSource("/bugs/YT1195/key.yang")
- .getModuleStatement(QNameModule.create(URI.create("foo")));
+ .getModuleStatement(QNameModule.create(XMLNamespace.of("foo")));
final ListEffectiveStatement grpFoo = module
.findFirstEffectiveSubstatement(GroupingEffectiveStatement.class).orElseThrow()
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertSame;
-import java.net.URI;
import java.util.List;
import java.util.stream.Collectors;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.stmt.AugmentEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.CaseEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceEffectiveStatement;
@Test
public void testAugmentStatementReuse() throws Exception {
final ModuleEffectiveStatement module = StmtTestUtils.parseYangSource("/bugs/YT1208/augment.yang")
- .getModuleStatement(QNameModule.create(URI.create("foo")));
+ .getModuleStatement(QNameModule.create(XMLNamespace.of("foo")));
final NotificationEffectiveStatement notif = module
.findFirstEffectiveSubstatement(NotificationEffectiveStatement.class).orElseThrow();
@Test
public void testCaseStatementReuse() throws Exception {
final ModuleEffectiveStatement module = StmtTestUtils.parseYangSource("/bugs/YT1208/case.yang")
- .getModuleStatement(QNameModule.create(URI.create("foo")));
+ .getModuleStatement(QNameModule.create(XMLNamespace.of("foo")));
final NotificationEffectiveStatement notif = module
.findFirstEffectiveSubstatement(NotificationEffectiveStatement.class).orElseThrow();
@Test
public void testChoiceStatementReuse() throws Exception {
final ModuleEffectiveStatement module = StmtTestUtils.parseYangSource("/bugs/YT1208/choice.yang")
- .getModuleStatement(QNameModule.create(URI.create("foo")));
+ .getModuleStatement(QNameModule.create(XMLNamespace.of("foo")));
final NotificationEffectiveStatement notif = module
.findFirstEffectiveSubstatement(NotificationEffectiveStatement.class).orElseThrow();
@Test
public void testGroupingStatementReuse() throws Exception {
final ModuleEffectiveStatement module = StmtTestUtils.parseYangSource("/bugs/YT1208/grouping.yang")
- .getModuleStatement(QNameModule.create(URI.create("foo")));
+ .getModuleStatement(QNameModule.create(XMLNamespace.of("foo")));
final NotificationEffectiveStatement notif = module
.findFirstEffectiveSubstatement(NotificationEffectiveStatement.class).orElseThrow();
@Test
public void testLeafStatementReuse() throws Exception {
final ModuleEffectiveStatement module = StmtTestUtils.parseYangSource("/bugs/YT1208/leaf.yang")
- .getModuleStatement(QNameModule.create(URI.create("foo")));
+ .getModuleStatement(QNameModule.create(XMLNamespace.of("foo")));
assertNotNull(module);
final NotificationEffectiveStatement notif = module
@Test
public void testLeafListStatementReuse() throws Exception {
final ModuleEffectiveStatement module = StmtTestUtils.parseYangSource("/bugs/YT1208/leaflist.yang")
- .getModuleStatement(QNameModule.create(URI.create("foo")));
+ .getModuleStatement(QNameModule.create(XMLNamespace.of("foo")));
final NotificationEffectiveStatement notif = module
.findFirstEffectiveSubstatement(NotificationEffectiveStatement.class).orElseThrow();
@Test
public void testListStatementReuse() throws Exception {
final ModuleEffectiveStatement module = StmtTestUtils.parseYangSource("/bugs/YT1208/list.yang")
- .getModuleStatement(QNameModule.create(URI.create("foo")));
+ .getModuleStatement(QNameModule.create(XMLNamespace.of("foo")));
final NotificationEffectiveStatement notif = module
.findFirstEffectiveSubstatement(NotificationEffectiveStatement.class).orElseThrow();
@Test
public void testTypedefStatementReuse() throws Exception {
final ModuleEffectiveStatement module = StmtTestUtils.parseYangSource("/bugs/YT1208/typedef.yang")
- .getModuleStatement(QNameModule.create(URI.create("foo")));
+ .getModuleStatement(QNameModule.create(XMLNamespace.of("foo")));
final TypedefEffectiveStatement grpBar = module
.findFirstEffectiveSubstatement(GroupingEffectiveStatement.class).orElseThrow()
@Test
public void testUsesStatementReuse() throws Exception {
final ModuleEffectiveStatement module = StmtTestUtils.parseYangSource("/bugs/YT1208/uses.yang")
- .getModuleStatement(QNameModule.create(URI.create("foo")));
+ .getModuleStatement(QNameModule.create(XMLNamespace.of("foo")));
assertNotNull(module);
final List<GroupingEffectiveStatement> groupings = module
.streamEffectiveSubstatements(GroupingEffectiveStatement.class).collect(Collectors.toList());
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertSame;
-import java.net.URI;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.stmt.GroupingEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.LeafEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement;
@Test
public void testWhenStatementReuse() throws Exception {
final ModuleEffectiveStatement module = StmtTestUtils.parseYangSource("/bugs/YT1209/when.yang")
- .getModuleStatement(QNameModule.create(URI.create("foo")));
+ .getModuleStatement(QNameModule.create(XMLNamespace.of("foo")));
final LeafEffectiveStatement grpFoo = module
.findFirstEffectiveSubstatement(GroupingEffectiveStatement.class).orElseThrow()
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertSame;
-import java.net.URI;
import java.util.List;
import java.util.stream.Collectors;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.stmt.AnyxmlEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ContainerEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.GroupingEffectiveStatement;
@Test
public void testActiontatementReuse() throws Exception {
final ModuleEffectiveStatement module = StmtTestUtils.parseYangSource("/bugs/YT1212/anyxml.yang")
- .getModuleStatement(QNameModule.create(URI.create("foo")));
+ .getModuleStatement(QNameModule.create(XMLNamespace.of("foo")));
final AnyxmlEffectiveStatement grpFoo = module
.findFirstEffectiveSubstatement(GroupingEffectiveStatement.class).orElseThrow()
@Test
public void testLeafStatementReuse() throws Exception {
final ModuleEffectiveStatement module = StmtTestUtils.parseYangSource("/bugs/YT1212/leaf.yang")
- .getModuleStatement(QNameModule.create(URI.create("foo")));
+ .getModuleStatement(QNameModule.create(XMLNamespace.of("foo")));
final LeafEffectiveStatement grpFoo = module
.findFirstEffectiveSubstatement(GroupingEffectiveStatement.class).orElseThrow()
@Test
public void testContainerStatementReuse() throws Exception {
final ModuleEffectiveStatement module = StmtTestUtils.parseYangSource("/bugs/YT1212/container.yang")
- .getModuleStatement(QNameModule.create(URI.create("foo")));
+ .getModuleStatement(QNameModule.create(XMLNamespace.of("foo")));
final NotificationEffectiveStatement notif =
module.findFirstEffectiveSubstatement(NotificationEffectiveStatement.class).orElseThrow();
import static org.junit.Assert.assertNotNull;
-import java.net.URI;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
public class YT841Test {
- private static final QNameModule FOO = QNameModule.create(URI.create("foo"), Revision.of("2018-01-02"));
+ private static final QNameModule FOO = QNameModule.create(XMLNamespace.of("foo"), Revision.of("2018-01-02"));
@Test
public void testFindDataSchemaNode() throws Exception {
import static org.junit.Assert.assertNotNull;
import java.io.IOException;
-import java.net.URI;
import java.net.URISyntaxException;
import java.util.Optional;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
public class YT971Test {
- private static final QNameModule NAMESPACE = QNameModule.create(URI.create("test"), Revision.of("2019-03-25"));
+ private static final QNameModule NAMESPACE = QNameModule.create(XMLNamespace.of("test"), Revision.of("2019-03-25"));
@Test
public void testEscapeLexer() throws URISyntaxException, IOException, YangSyntaxErrorException, ReactorException {
import static org.junit.Assert.assertTrue;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.assertPathEquals;
-import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
public class YangParserSimpleTest {
- private static final QNameModule SN = QNameModule.create(URI.create("urn:opendaylight:simple-nodes"),
+ private static final QNameModule SN = QNameModule.create(XMLNamespace.of("urn:opendaylight:simple-nodes"),
Revision.of("2013-07-30"));
private static final QName SN_NODES = QName.create(SN, "nodes");
private static final SchemaPath SN_NODES_PATH = SchemaPath.create(true, SN_NODES);
}
- private static final URI NS = URI.create("urn:opendaylight:simple-nodes");
+ private static final XMLNamespace NS = XMLNamespace.of("urn:opendaylight:simple-nodes");
private static SchemaPath createPath(final String... names) {
final Revision rev = Revision.of("2013-07-30");
import com.google.common.collect.Range;
import com.google.common.collect.RangeSet;
import java.io.IOException;
-import java.net.URI;
import java.net.URISyntaxException;
import java.text.ParseException;
import java.util.ArrayList;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.CrossSourceStatementReactor.BuildAction;
public class YangParserTest {
- private static final QNameModule FOO = QNameModule.create(URI.create("urn:opendaylight.foo"),
+ private static final QNameModule FOO = QNameModule.create(XMLNamespace.of("urn:opendaylight.foo"),
Revision.of("2013-02-27"));
- private static final QNameModule BAR = QNameModule.create(URI.create("urn:opendaylight.bar"),
+ private static final QNameModule BAR = QNameModule.create(XMLNamespace.of("urn:opendaylight.bar"),
Revision.of("2013-07-03"));
- private static final QNameModule BAZ = QNameModule.create(URI.create("urn:opendaylight.baz"),
+ private static final QNameModule BAZ = QNameModule.create(XMLNamespace.of("urn:opendaylight.baz"),
Revision.of("2013-02-27"));
private SchemaContext context;
import com.google.common.collect.Iterables;
import com.google.common.collect.Range;
-import java.net.URI;
import java.util.Collection;
import java.util.Map;
import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.Uint8;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementStreamSource;
public class YangParserWithContextTest {
- private static final URI T1_NS = URI.create("urn:simple.demo.test1");
- private static final URI T2_NS = URI.create("urn:simple.demo.test2");
- private static final URI T3_NS = URI.create("urn:simple.demo.test3");
+ private static final XMLNamespace T1_NS = XMLNamespace.of("urn:simple.demo.test1");
+ private static final XMLNamespace T2_NS = XMLNamespace.of("urn:simple.demo.test2");
+ private static final XMLNamespace T3_NS = XMLNamespace.of("urn:simple.demo.test3");
private static final Revision REV = Revision.of("2013-06-18");
private static final StatementStreamSource BAR = sourceForResource("/model/bar.yang");
assertTrue(leaf.getType() instanceof Uint16TypeDefinition);
final Uint16TypeDefinition leafType = (Uint16TypeDefinition) leaf.getType();
QName qname = leafType.getQName();
- assertEquals(URI.create("urn:simple.demo.test1"), qname.getNamespace());
+ assertEquals(XMLNamespace.of("urn:simple.demo.test1"), qname.getNamespace());
assertEquals(Revision.ofNullable("2013-06-18"), qname.getRevision());
assertEquals("port-number", qname.getLocalName());
final Uint16TypeDefinition leafBaseType = leafType.getBaseType();
qname = leafBaseType.getQName();
- assertEquals(URI.create("urn:ietf:params:xml:ns:yang:ietf-inet-types"), qname.getNamespace());
+ assertEquals(XMLNamespace.of("urn:ietf:params:xml:ns:yang:ietf-inet-types"), qname.getNamespace());
assertEquals(Revision.ofNullable("2010-09-24"), qname.getRevision());
assertEquals("port-number", qname.getLocalName());
.buildEffective();
final Module testModule = context.findModule("test2", Revision.of("2013-06-18")).get();
- final Module contextModule = context.findModules(URI.create("urn:opendaylight.baz")).iterator().next();
+ final Module contextModule = context.findModules(XMLNamespace.of("urn:opendaylight.baz")).iterator().next();
assertNotNull(contextModule);
final Collection<? extends GroupingDefinition> groupings = contextModule.getGroupings();
assertEquals(1, groupings.size());
final UsesNode usesNode = usesNodes.iterator().next();
// test grouping path
- assertEquals(QName.create(URI.create("urn:opendaylight.baz"), Revision.of("2013-02-27"), "target"),
+ assertEquals(QName.create(XMLNamespace.of("urn:opendaylight.baz"), Revision.of("2013-02-27"), "target"),
usesNode.getSourceGrouping().getQName());
// test refine
final IdentitySchemaNode identity = identities.iterator().next();
final QName idQName = identity.getQName();
- assertEquals(URI.create("urn:simple.demo.test3"), idQName.getNamespace());
+ assertEquals(XMLNamespace.of("urn:simple.demo.test3"), idQName.getNamespace());
assertEquals(Revision.ofNullable("2013-06-18"), idQName.getRevision());
assertEquals("pt", idQName.getLocalName());
final IdentitySchemaNode baseIdentity = Iterables.getOnlyElement(identity.getBaseIdentities());
final QName idBaseQName = baseIdentity.getQName();
- assertEquals(URI.create("urn:custom.types.demo"), idBaseQName.getNamespace());
+ assertEquals(XMLNamespace.of("urn:custom.types.demo"), idBaseQName.getNamespace());
assertEquals(Revision.ofNullable("2012-04-16"), idBaseQName.getRevision());
assertEquals("service-type", idBaseQName.getLocalName());
}
final UnrecognizedStatement un = unknownNodes.iterator().next();
final QName unType = un.statementDefinition().getStatementName();
- assertEquals(URI.create("urn:custom.types.demo"), unType.getNamespace());
+ assertEquals(XMLNamespace.of("urn:custom.types.demo"), unType.getNamespace());
assertEquals(Revision.ofNullable("2012-04-16"), unType.getRevision());
assertEquals("mountpoint", unType.getLocalName());
assertEquals("point", un.argument());
assertEquals(Optional.of("system/user ref"), dev.getReference());
- final URI expectedNS = URI.create("urn:opendaylight.bar");
+ final XMLNamespace expectedNS = XMLNamespace.of("urn:opendaylight.bar");
final Revision expectedRev = Revision.of("2013-07-03");
assertEquals(Absolute.of(
import static org.junit.Assert.assertTrue;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
-import java.net.URI;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
private static final StatementStreamSource TYPEFILE4 = sourceForResource(
"/semantic-statement-parser/identityreftest.yang");
- private static final QNameModule TYPES2_MODULE = QNameModule.create(URI.create("types2"));
+ private static final QNameModule TYPES2_MODULE = QNameModule.create(XMLNamespace.of("types2"));
private static final QName LF_DECIMAL = QName.create(TYPES2_MODULE, "lf-decimal");
private static final QName LF_MY_STRING = QName.create(TYPES2_MODULE, "lf-my-string");
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import java.net.URI;
import org.junit.Test;
import org.opendaylight.yangtools.concepts.SemVer;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.repo.api.StatementParserMode;
"/openconfig-version/border-case/border-case-valid-major", StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModules(URI.create("foo")).iterator().next();
- Module semVer = context.findModules(URI.create("http://openconfig.net/yang/openconfig-ext")).iterator().next();
+ Module foo = context.findModules(XMLNamespace.of("foo")).iterator().next();
+ Module semVer = context.findModules(XMLNamespace.of("http://openconfig.net/yang/openconfig-ext"))
+ .iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
"/openconfig-version/border-case/border-case-valid-minor", StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModules(URI.create("foo")).iterator().next();
- Module semVer = context.findModules(URI.create("http://openconfig.net/yang/openconfig-ext")).iterator().next();
+ Module foo = context.findModules(XMLNamespace.of("foo")).iterator().next();
+ Module semVer = context.findModules(XMLNamespace.of("http://openconfig.net/yang/openconfig-ext"))
+ .iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
"/openconfig-version/border-case/border-case-valid-patch", StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModules(URI.create("foo")).iterator().next();
- Module semVer = context.findModules(URI.create("http://openconfig.net/yang/openconfig-ext")).iterator().next();
+ Module foo = context.findModules(XMLNamespace.of("foo")).iterator().next();
+ Module semVer = context.findModules(XMLNamespace.of("http://openconfig.net/yang/openconfig-ext"))
+ .iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
-import java.net.URI;
import org.junit.Test;
import org.opendaylight.yangtools.concepts.SemVer;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.repo.api.StatementParserMode;
private static void verifySchemaContextTest1(final SchemaContext context) {
assertNotNull(context);
- final Module foo = context.findModules(URI.create("foo")).iterator().next();
- final Module semVer = context.findModules(URI.create("http://openconfig.net/yang/openconfig-ext"))
+ final Module foo = context.findModules(XMLNamespace.of("foo")).iterator().next();
+ final Module semVer = context.findModules(XMLNamespace.of("http://openconfig.net/yang/openconfig-ext"))
.iterator().next();
// check module versions
private static void verifySchemaContextTest2(final SchemaContext context) {
assertNotNull(context);
- final Module foo = context.findModules(URI.create("foo")).iterator().next();
- final Module semVer = context.findModules(URI.create("http://openconfig.net/yang/openconfig-ext"))
+ final Module foo = context.findModules(XMLNamespace.of("foo")).iterator().next();
+ final Module semVer = context.findModules(XMLNamespace.of("http://openconfig.net/yang/openconfig-ext"))
.iterator().next();
// check module versions
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import java.net.URI;
import java.util.Optional;
import org.junit.Test;
import org.opendaylight.yangtools.concepts.SemVer;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.repo.api.StatementParserMode;
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModules(new URI("foo")).iterator().next();
- Module bar = context.findModules(new URI("bar")).iterator().next();
+ Module foo = context.findModules(XMLNamespace.of("foo")).iterator().next();
+ Module bar = context.findModules(XMLNamespace.of("bar")).iterator().next();
assertEquals(Optional.empty(), foo.getSemanticVersion());
assertEquals(Optional.empty(), bar.getSemanticVersion());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModules(new URI("foo")).iterator().next();
- Module bar = context.findModules(new URI("bar")).iterator().next();
+ Module foo = context.findModules(XMLNamespace.of("foo")).iterator().next();
+ Module bar = context.findModules(XMLNamespace.of("bar")).iterator().next();
assertEquals(Optional.empty(), foo.getSemanticVersion());
assertEquals(SemVer.valueOf("0.99.99"), bar.getSemanticVersion().get());
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import java.net.URI;
import org.junit.Test;
import org.opendaylight.yangtools.concepts.SemVer;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.repo.api.StatementParserMode;
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModules(new URI("foo")).iterator().next();
- Module bar = context.findModules(new URI("bar")).iterator().next();
- Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
+ Module foo = context.findModules(XMLNamespace.of("foo")).iterator().next();
+ Module bar = context.findModules(XMLNamespace.of("bar")).iterator().next();
+ Module semVer = context.findModules(XMLNamespace.of("http://openconfig.net/yang/openconfig-ext"))
+ .iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModules(new URI("foo")).iterator().next();
- Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
+ Module foo = context.findModules(XMLNamespace.of("foo")).iterator().next();
+ Module semVer = context.findModules(XMLNamespace.of("http://openconfig.net/yang/openconfig-ext"))
+ .iterator().next();
Module bar = StmtTestUtils.findImportedModule(context, foo, "bar");
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import java.net.URI;
import org.junit.Test;
import org.opendaylight.yangtools.concepts.SemVer;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.repo.api.StatementParserMode;
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
+ Module semVer = context.findModules(XMLNamespace.of("http://openconfig.net/yang/openconfig-ext"))
+ .iterator().next();
assertEquals(SemVer.valueOf("1.0.0"), semVer.getSemanticVersion().get());
}
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import java.net.URI;
import org.junit.Test;
import org.opendaylight.yangtools.concepts.SemVer;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModules(new URI("foo")).iterator().next();
- Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
+ Module foo = context.findModules(XMLNamespace.of("foo")).iterator().next();
+ Module semVer = context.findModules(XMLNamespace.of("http://openconfig.net/yang/openconfig-ext"))
+ .iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModules(new URI("foo")).iterator().next();
- Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
+ Module foo = context.findModules(XMLNamespace.of("foo")).iterator().next();
+ Module semVer = context.findModules(XMLNamespace.of("http://openconfig.net/yang/openconfig-ext"))
+ .iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import java.net.URI;
import org.junit.Test;
import org.opendaylight.yangtools.concepts.SemVer;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.repo.api.StatementParserMode;
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModules(new URI("foo")).iterator().next();
- Module bar = context.findModules(new URI("bar")).iterator().next();
- Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
+ Module foo = context.findModules(XMLNamespace.of("foo")).iterator().next();
+ Module bar = context.findModules(XMLNamespace.of("bar")).iterator().next();
+ Module semVer = context.findModules(XMLNamespace.of("http://openconfig.net/yang/openconfig-ext"))
+ .iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModules(new URI("foo")).iterator().next();
- Module bar = context.findModules(new URI("bar")).iterator().next();
- Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
+ Module foo = context.findModules(XMLNamespace.of("foo")).iterator().next();
+ Module bar = context.findModules(XMLNamespace.of("bar")).iterator().next();
+ Module semVer = context.findModules(XMLNamespace.of("http://openconfig.net/yang/openconfig-ext"))
+ .iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModules(new URI("foo")).iterator().next();
- Module bar = context.findModules(new URI("bar")).iterator().next();
- Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
+ Module foo = context.findModules(XMLNamespace.of("foo")).iterator().next();
+ Module bar = context.findModules(XMLNamespace.of("bar")).iterator().next();
+ Module semVer = context.findModules(XMLNamespace.of("http://openconfig.net/yang/openconfig-ext"))
+ .iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import java.net.URI;
import org.junit.Test;
import org.opendaylight.yangtools.concepts.SemVer;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModules(new URI("foo")).iterator().next();
- Module bar = context.findModules(new URI("bar")).iterator().next();
- Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
+ Module foo = context.findModules(XMLNamespace.of("foo")).iterator().next();
+ Module bar = context.findModules(XMLNamespace.of("bar")).iterator().next();
+ Module semVer = context.findModules(XMLNamespace.of("http://openconfig.net/yang/openconfig-ext"))
+ .iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModules(new URI("foo")).iterator().next();
- Module bar = context.findModules(new URI("bar")).iterator().next();
- Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
+ Module foo = context.findModules(XMLNamespace.of("foo")).iterator().next();
+ Module bar = context.findModules(XMLNamespace.of("bar")).iterator().next();
+ Module semVer = context.findModules(XMLNamespace.of("http://openconfig.net/yang/openconfig-ext"))
+ .iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModules(new URI("foo")).iterator().next();
- Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
+ Module foo = context.findModules(XMLNamespace.of("foo")).iterator().next();
+ Module semVer = context.findModules(XMLNamespace.of("http://openconfig.net/yang/openconfig-ext"))
+ .iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModules(new URI("foo")).iterator().next();
- Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
+ Module foo = context.findModules(XMLNamespace.of("foo")).iterator().next();
+ Module semVer = context.findModules(XMLNamespace.of("http://openconfig.net/yang/openconfig-ext"))
+ .iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModules(new URI("foo")).iterator().next();
- Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
+ Module foo = context.findModules(XMLNamespace.of("foo")).iterator().next();
+ Module semVer = context.findModules(XMLNamespace.of("http://openconfig.net/yang/openconfig-ext"))
+ .iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModules(new URI("foo")).iterator().next();
- Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
+ Module foo = context.findModules(XMLNamespace.of("foo")).iterator().next();
+ Module semVer = context.findModules(XMLNamespace.of("http://openconfig.net/yang/openconfig-ext"))
+ .iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("2016.1.1"), foo.getSemanticVersion().get());
import static org.junit.Assert.fail;
import java.io.IOException;
-import java.net.URI;
import java.net.URISyntaxException;
import org.junit.Test;
import org.opendaylight.yangtools.concepts.SemVer;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.repo.api.StatementParserMode;
import org.xml.sax.SAXException;
public class YinOpenconfigVersionTest {
-
@Test
public void basicTest() throws URISyntaxException, SAXException, IOException, ReactorException {
SchemaContext context = StmtTestUtils.parseYinSources("/openconfig-version/yin-input/basic",
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModules(URI.create("foo")).iterator().next();
- Module bar = context.findModules(URI.create("bar")).iterator().next();
- Module semVer = context.findModules(URI.create("http://openconfig.net/yang/openconfig-ext")).iterator().next();
+ Module foo = context.findModules(XMLNamespace.of("foo")).iterator().next();
+ Module bar = context.findModules(XMLNamespace.of("bar")).iterator().next();
+ Module semVer = context.findModules(XMLNamespace.of("http://openconfig.net/yang/openconfig-ext"))
+ .iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModules(URI.create("foo")).iterator().next();
- Module semVer = context.findModules(URI.create("http://openconfig.net/yang/openconfig-ext")).iterator().next();
+ Module foo = context.findModules(XMLNamespace.of("foo")).iterator().next();
+ Module semVer = context.findModules(XMLNamespace.of("http://openconfig.net/yang/openconfig-ext"))
+ .iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
import static org.junit.Assert.assertEquals;
-import java.net.URI;
import java.net.URISyntaxException;
import org.junit.Test;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.stmt.TestUtils;
public class YinFileHeaderStmtsTest extends AbstractYinModulesTest {
-
@Test
public void testYinFileHeader() throws URISyntaxException {
Module testModule = TestUtils.findModule(context, "config").get();
assertEquals(YangVersion.VERSION_1, testModule.getYangVersion());
- assertEquals(new URI("urn:opendaylight:params:xml:ns:yang:controller:config"), testModule.getNamespace());
+ assertEquals(XMLNamespace.of("urn:opendaylight:params:xml:ns:yang:controller:config"),
+ testModule.getNamespace());
assertEquals("config", testModule.getPrefix());
}
}
import static org.junit.Assert.assertNotNull;
import java.io.IOException;
-import java.net.URI;
import java.net.URISyntaxException;
import java.util.Iterator;
import org.junit.Before;
import org.junit.Test;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.Submodule;
import org.xml.sax.SAXException;
public class YinFileIncludeStmtTest {
-
private SchemaContext context;
@Before
Submodule childModule = submodulesIterator.next() ;
assertNotNull(childModule);
assertEquals("child", childModule.getName());
- assertEquals(new URI("urn:opendaylight/parent"), childModule.getNamespace());
+ assertEquals(XMLNamespace.of("urn:opendaylight/parent"), childModule.getNamespace());
}
}
*/
package org.opendaylight.yangtools.yang.parser.spi.source;
-import java.net.URI;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour;
import org.opendaylight.yangtools.yang.parser.spi.meta.ParserNamespace;
/**
* Pre-linkage source-specific mapping of prefixes to module namespaces.
*/
-public interface ImpPrefixToNamespace extends ParserNamespace<String, URI> {
- NamespaceBehaviour<String, URI, @NonNull ImpPrefixToNamespace> BEHAVIOUR =
+public interface ImpPrefixToNamespace extends ParserNamespace<String, XMLNamespace> {
+ NamespaceBehaviour<String, XMLNamespace, @NonNull ImpPrefixToNamespace> BEHAVIOUR =
NamespaceBehaviour.rootStatementLocal(ImpPrefixToNamespace.class);
}
*/
package org.opendaylight.yangtools.yang.parser.spi.source;
-import java.net.URI;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.NamespaceBehaviour;
import org.opendaylight.yangtools.yang.parser.spi.meta.ParserNamespace;
/**
* Pre-linkage global mapping of module names to namespaces.
*/
-public interface ModuleNameToNamespace extends ParserNamespace<String, URI> {
- NamespaceBehaviour<String, URI, @NonNull ModuleNameToNamespace> BEHAVIOUR =
+public interface ModuleNameToNamespace extends ParserNamespace<String, XMLNamespace> {
+ NamespaceBehaviour<String, XMLNamespace, @NonNull ModuleNameToNamespace> BEHAVIOUR =
NamespaceBehaviour.global(ModuleNameToNamespace.class);
}
*/
package org.opendaylight.yangtools.yang.parser.spi.source;
-import java.net.URISyntaxException;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QNameModule;
*
* @param namespace XML Namespace
* @return QNameModule associated with supplied namespace, or null if prefix is not defined.
- * @throws URISyntaxException if the input string is not valid URI
+ * @throws IllegalArgumentException if the input string is not valid URI
*/
- @Nullable QNameModule getByNamespace(String namespace) throws URISyntaxException;
+ @Nullable QNameModule getByNamespace(String namespace);
}
*/
package org.opendaylight.yangtools.yang.parser.spi.source;
-import java.net.URI;
-import java.net.URISyntaxException;
import java.util.HashMap;
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
/**
* Map-based {@link PrefixToModule} namespace. This class is NOT thread-safe.
*/
public class PrefixToModuleMap implements PrefixToModule {
private final Map<String, QNameModule> prefixToModuleMap = new HashMap<>();
- private final Map<URI, QNameModule> namespaceToModuleMap = new HashMap<>();
+ private final Map<XMLNamespace, QNameModule> namespaceToModuleMap = new HashMap<>();
public void put(final String prefix, final QNameModule module) {
prefixToModuleMap.put(prefix, module);
}
@Override
- public QNameModule getByNamespace(final String namespace) throws URISyntaxException {
- return namespaceToModuleMap.get(new URI(namespace));
+ public QNameModule getByNamespace(final String namespace) {
+ return namespaceToModuleMap.get(XMLNamespace.of(namespace));
}
}
*/
package org.opendaylight.yangtools.yang.parser.spi.source;
-import java.net.URI;
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.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
/**
* @param localName localName of requested statement
* @return StatementDefinition
*/
- @Nullable StatementDefinition getByNamespaceAndLocalName(@NonNull URI namespace, @NonNull String localName);
+ @Nullable StatementDefinition getByNamespaceAndLocalName(@NonNull XMLNamespace namespace,
+ @NonNull String localName);
}
import static java.util.Objects.requireNonNull;
-import java.net.URI;
import java.util.HashMap;
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
}
@Override
- public StatementDefinition getByNamespaceAndLocalName(final URI namespace, final String localName) {
+ public StatementDefinition getByNamespaceAndLocalName(final XMLNamespace namespace, final String localName) {
return noRevQNameToSupport.get(QName.create(namespace, localName));
}
}
import static org.junit.Assert.assertEquals;
import com.google.common.collect.ImmutableBiMap;
-import java.net.URI;
import javax.xml.xpath.XPathExpressionException;
import org.eclipse.jdt.annotation.Nullable;
import org.junit.Before;
import org.opendaylight.yangtools.yang.common.BiMapYangNamespaceContext;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.common.YangNamespaceContext;
import org.opendaylight.yangtools.yang.xpath.api.YangBinaryExpr;
import org.opendaylight.yangtools.yang.xpath.api.YangBinaryOperator;
@SuppressWarnings("null")
public class XPathParserTest {
- private static final QNameModule DEFNS = QNameModule.create(URI.create("defaultns"));
+ private static final QNameModule DEFNS = QNameModule.create(XMLNamespace.of("defaultns"));
private static final YangNamespaceContext CONTEXT = new BiMapYangNamespaceContext(ImmutableBiMap.of(
"def", DEFNS,
- "foo", QNameModule.create(URI.create("foo")),
- "bar", QNameModule.create(URI.create("bar"))));
+ "foo", QNameModule.create(XMLNamespace.of("foo")),
+ "bar", QNameModule.create(XMLNamespace.of("bar"))));
private @Nullable AntlrXPathParser parser;
Code Review / yangtools.git / commitdiff