import static com.google.common.base.Preconditions.checkArgument;
import static java.util.Objects.requireNonNull;
-import com.google.common.annotations.Beta;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.concepts.Identifier;
/**
* Abstract superclass for sharing QName references, which can either be resolved {@link QName}s or unresolved
- * {@link UnqualifiedQName} and {@link QualifiedQName}s.
+ * {@link UnresolvedQName.Unqualified} and {@link UnresolvedQName.Qualified}s.
*/
-@Beta
+// FIXME: sealed to allow QName and UnresolvedQName only when we have JDK17+
@NonNullByDefault
public abstract class AbstractQName implements Identifier, WritableObject {
private static final long serialVersionUID = 1L;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Qualified;
/**
- * Externalizable proxy for {@link QualifiedQName}.
+ * Externalizable proxy for {@link Qualified}.
*/
final class QQNv1 implements Externalizable {
private static final long serialVersionUID = 1L;
- private QualifiedQName qname;
+ private Qualified qname;
@SuppressWarnings("checkstyle:redundantModifier")
public QQNv1() {
// For Externalizable
}
- QQNv1(final QualifiedQName qname) {
+ QQNv1(final Qualified qname) {
this.qname = requireNonNull(qname);
}
@Override
public void readExternal(final ObjectInput in) throws IOException {
- qname = QualifiedQName.readFrom(in);
+ qname = Qualified.readFrom(in);
}
Object readResolve() {
+++ /dev/null
-/*
- * Copyright (c) 2019 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.annotations.Beta;
-import com.google.common.base.MoreObjects;
-import com.google.common.collect.Interner;
-import com.google.common.collect.Interners;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.io.DataInput;
-import java.io.DataOutput;
-import java.io.IOException;
-import java.util.Optional;
-import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
-
-/**
- * An unresolved, qualified {@link QName}. It is guaranteed to hold a valid {@link #getLocalName()} bound to a namespace
- * identified through a prefix string, but remains unresolved. A resolved {@link QName} can be obtained through
- * {@link #bindTo(YangNamespaceContext)}.
- */
-@Beta
-@NonNullByDefault
-public final class QualifiedQName extends AbstractQName implements Comparable<QualifiedQName> {
- private static final long serialVersionUID = 1L;
- private static final Interner<QualifiedQName> INTERNER = Interners.newWeakInterner();
-
- private final String prefix;
-
- private QualifiedQName(final String prefix, final String localName) {
- super(localName);
- this.prefix = requireNonNull(prefix);
- }
-
- public static QualifiedQName of(final String prefix, final String localName) {
- return new QualifiedQName(checkLocalName(prefix), checkLocalName(localName));
- }
-
- /**
- * Read an QualifiedQName from a DataInput. The format is expected to match the output format of
- * {@link #writeTo(DataOutput)}.
- *
- * @param in DataInput to read
- * @return An QualifiedQName instance
- * @throws IOException if I/O error occurs
- */
- public static QualifiedQName readFrom(final DataInput in) throws IOException {
- return of(in.readUTF(), in.readUTF());
- }
-
- public Optional<QName> bindTo(final YangNamespaceContext namespaceContext) {
- return namespaceContext.findNamespaceForPrefix(prefix).map(this::bindTo);
- }
-
- @Override
- @SuppressFBWarnings(value = "ES_COMPARING_STRINGS_WITH_EQ", justification = "Interning identity check")
- public QualifiedQName intern() {
- // Make sure to intern the string and check whether it refers to the same name as we are
- final String name = getLocalName();
- final String internedName = name.intern();
- final QualifiedQName template = internedName == name ? this : new QualifiedQName(prefix.intern(), internedName);
- return INTERNER.intern(template);
- }
-
- @Override
- @SuppressWarnings("checkstyle:parameterName")
- public int compareTo(final QualifiedQName o) {
- return getLocalName().compareTo(o.getLocalName());
- }
-
- @Override
- public void writeTo(final DataOutput out) throws IOException {
- out.writeUTF(getLocalName());
- }
-
- @Override
- public int hashCode() {
- return getLocalName().hashCode();
- }
-
- @Override
- public boolean equals(final @Nullable Object obj) {
- return this == obj || obj instanceof QualifiedQName
- && getLocalName().equals(((AbstractQName) obj).getLocalName());
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(this).add("localName", getLocalName()).toString();
- }
-
- @Override
- Object writeReplace() {
- return new QQNv1(this);
- }
-}
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
/**
- * Externalizable proxy for {@link UnqualifiedQName}.
+ * Externalizable proxy for {@link Unqualified}.
*/
final class UQNv1 implements Externalizable {
private static final long serialVersionUID = 1L;
- private UnqualifiedQName qname;
+ private Unqualified qname;
@SuppressWarnings("checkstyle:redundantModifier")
public UQNv1() {
// For Externalizable
}
- UQNv1(final UnqualifiedQName qname) {
+ UQNv1(final Unqualified qname) {
this.qname = requireNonNull(qname);
}
@Override
public void readExternal(final ObjectInput in) throws IOException {
- qname = UnqualifiedQName.readFrom(in);
+ qname = Unqualified.readFrom(in);
}
Object readResolve() {
+++ /dev/null
-/*
- * Copyright (c) 2019 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 com.google.common.annotations.Beta;
-import com.google.common.base.MoreObjects;
-import com.google.common.collect.Interner;
-import com.google.common.collect.Interners;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.io.DataInput;
-import java.io.DataOutput;
-import java.io.IOException;
-import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.eclipse.jdt.annotation.Nullable;
-
-/**
- * An unresolved, unqualified {@link QName}. It is guaranteed to hold a valid {@link #getLocalName()}, in the default
- * namespace, which is not resolved. A resolved {@link QName} can be constructed through {@link #bindTo(QNameModule)}.
- */
-@Beta
-@NonNullByDefault
-public final class UnqualifiedQName extends AbstractQName implements Comparable<UnqualifiedQName> {
- private static final long serialVersionUID = 1L;
- private static final Interner<UnqualifiedQName> INTERNER = Interners.newWeakInterner();
-
- private UnqualifiedQName(final String localName) {
- super(localName);
- }
-
- /**
- * Create a new unqualified QName.
- *
- * @param localName The local name of this unqualified QName
- * @return An UnqualifiedQName instance
- * @throws NullPointerException if localName is null
- * @throws IllegalArgumentException if localName is not a valid YANG identifier
- */
- public static UnqualifiedQName of(final String localName) {
- return new UnqualifiedQName(checkLocalName(localName));
- }
-
- /**
- * Create a new unqualified QName.
- *
- * @param localName The local name of this unqualified QName
- * @return An UnqualifiedQName instance, or null if localName is not valid
- */
- @SuppressFBWarnings(value = "NP_NONNULL_RETURN_VIOLATION", justification = "Non-grok of @Nullable")
- public static @Nullable UnqualifiedQName tryCreate(final String localName) {
- return isValidLocalName(localName) ? new UnqualifiedQName(localName) : null;
- }
-
- /**
- * Read an UnqualifiedQName from a DataInput. The format is expected to match the output format of
- * {@link #writeTo(DataOutput)}.
- *
- * @param in DataInput to read
- * @return An UnqualifiedQName instance
- * @throws IOException if I/O error occurs
- */
- public static UnqualifiedQName readFrom(final DataInput in) throws IOException {
- return of(in.readUTF());
- }
-
- @Override
- @SuppressFBWarnings(value = "ES_COMPARING_STRINGS_WITH_EQ", justification = "Interning identity check")
- public UnqualifiedQName intern() {
- // Make sure to intern the string and check whether it refers to the same name as we are
- final String name = getLocalName();
- final String internedName = name.intern();
- final UnqualifiedQName template = internedName == name ? this : new UnqualifiedQName(internedName);
- return INTERNER.intern(template);
- }
-
- @Override
- @SuppressWarnings("checkstyle:parameterName")
- public int compareTo(final UnqualifiedQName o) {
- return getLocalName().compareTo(o.getLocalName());
- }
-
- @Override
- public void writeTo(final DataOutput out) throws IOException {
- out.writeUTF(getLocalName());
- }
-
- @Override
- public int hashCode() {
- return getLocalName().hashCode();
- }
-
- @Override
- public boolean equals(final @Nullable Object obj) {
- return this == obj || obj instanceof UnqualifiedQName
- && getLocalName().equals(((AbstractQName) obj).getLocalName());
- }
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(this).add("localName", getLocalName()).toString();
- }
-
- @Override
- Object writeReplace() {
- return new UQNv1(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 java.util.Objects.requireNonNull;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.collect.Interner;
+import com.google.common.collect.Interners;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import java.io.DataInput;
+import java.io.DataOutput;
+import java.io.IOException;
+import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+
+/**
+ * A {@link QName} equivalent which has not been resolved. There are two subclasses:
+ * <ol>
+ * <li>{@link Unqualified}, which holds only a local name available through {@link #getLocalName()}.<li>
+ * <li>{@link Qualified}, which also holds a string prefix available via {@link Qualified#getPrefix()}.</li>
+ * </ol>
+ */
+// FIXME: sealed to allow Qualified and Unqualified only when we have JDK17+
+@NonNullByDefault
+public abstract class UnresolvedQName extends AbstractQName {
+ /**
+ * An unresolved, qualified {@link QName}. It is guaranteed to hold a valid {@link #getLocalName()} bound to a
+ * namespace identified through a prefix string, but remains unresolved. A resolved {@link QName} can be obtained
+ * through {@link #bindTo(YangNamespaceContext)}.
+ */
+ public static final class Qualified extends UnresolvedQName implements Comparable<Qualified> {
+ private static final long serialVersionUID = 1L;
+ private static final Interner<Qualified> INTERNER = Interners.newWeakInterner();
+
+ private final String prefix;
+
+ private Qualified(final String prefix, final String localName) {
+ super(localName);
+ this.prefix = requireNonNull(prefix);
+ }
+
+ /**
+ * Read an QualifiedQName from a DataInput. The format is expected to match the output format of
+ * {@link #writeTo(DataOutput)}.
+ *
+ * @param in DataInput to read
+ * @return An QualifiedQName instance
+ * @throws IOException if I/O error occurs
+ */
+ public static Qualified readFrom(final DataInput in) throws IOException {
+ return qualified(in.readUTF(), in.readUTF());
+ }
+
+ @Override
+ public @NonNull String getPrefix() {
+ return prefix;
+ }
+
+ public Optional<QName> bindTo(final YangNamespaceContext namespaceContext) {
+ return namespaceContext.findNamespaceForPrefix(prefix).map(this::bindTo);
+ }
+
+ @Override
+ @SuppressFBWarnings(value = "ES_COMPARING_STRINGS_WITH_EQ", justification = "Interning identity check")
+ public Qualified intern() {
+ // Make sure to intern the string and check whether it refers to the same name as we are
+ final String name = getLocalName();
+ final String internedName = name.intern();
+ final Qualified template = internedName == name ? this : new Qualified(prefix.intern(), internedName);
+ return INTERNER.intern(template);
+ }
+
+ @Override
+ @SuppressWarnings("checkstyle:parameterName")
+ public int compareTo(final Qualified o) {
+ return getLocalName().compareTo(o.getLocalName());
+ }
+
+ @Override
+ public void writeTo(final DataOutput out) throws IOException {
+ out.writeUTF(getLocalName());
+ }
+
+ @Override
+ public int hashCode() {
+ return getLocalName().hashCode();
+ }
+
+ @Override
+ public boolean equals(final @Nullable Object obj) {
+ return this == obj || obj instanceof Qualified && getLocalName().equals(((Qualified) obj).getLocalName());
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(this).add("localName", getLocalName()).toString();
+ }
+
+ @Override
+ Object writeReplace() {
+ return new QQNv1(this);
+ }
+ }
+
+ /**
+ * An unresolved, unqualified {@link QName}. It is guaranteed to hold a valid {@link #getLocalName()}, in the
+ * default namespace, which is not resolved. A resolved {@link QName} can be constructed through
+ * {@link #bindTo(QNameModule)}.
+ */
+ public static final class Unqualified extends UnresolvedQName implements Comparable<Unqualified> {
+ private static final long serialVersionUID = 1L;
+ private static final Interner<Unqualified> INTERNER = Interners.newWeakInterner();
+
+ private Unqualified(final String localName) {
+ super(localName);
+ }
+
+ /**
+ * Read an UnqualifiedQName from a DataInput. The format is expected to match the output format of
+ * {@link #writeTo(DataOutput)}.
+ *
+ * @param in DataInput to read
+ * @return An UnqualifiedQName instance
+ * @throws IOException if I/O error occurs
+ */
+ public static Unqualified readFrom(final DataInput in) throws IOException {
+ return unqualified(in.readUTF());
+ }
+
+ @Override
+ @SuppressFBWarnings(value = "ES_COMPARING_STRINGS_WITH_EQ", justification = "Interning identity check")
+ public Unqualified intern() {
+ // Make sure to intern the string and check whether it refers to the same name as we are
+ final String name = getLocalName();
+ final String internedName = name.intern();
+ final Unqualified template = internedName == name ? this : new Unqualified(internedName);
+ return INTERNER.intern(template);
+ }
+
+ @Override
+ @SuppressFBWarnings(value = "NP_NONNULL_RETURN_VIOLATION", justification = "Non-grok of @Nullable")
+ public @Nullable String getPrefix() {
+ return null;
+ }
+
+ @Override
+ @SuppressWarnings("checkstyle:parameterName")
+ public int compareTo(final Unqualified o) {
+ return getLocalName().compareTo(o.getLocalName());
+ }
+
+ @Override
+ public void writeTo(final DataOutput out) throws IOException {
+ out.writeUTF(getLocalName());
+ }
+
+ @Override
+ public int hashCode() {
+ return getLocalName().hashCode();
+ }
+
+ @Override
+ public boolean equals(final @Nullable Object obj) {
+ return this == obj || obj instanceof Unqualified
+ && getLocalName().equals(((AbstractQName) obj).getLocalName());
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(this).add("localName", getLocalName()).toString();
+ }
+
+ @Override
+ Object writeReplace() {
+ return new UQNv1(this);
+ }
+ }
+
+ private static final long serialVersionUID = 1L;
+
+ private UnresolvedQName(final String localName) {
+ super(localName);
+ }
+
+ /**
+ * Create a new qualified unresolved QName.
+ *
+ * @param prefix The prefix on this qualified QName
+ * @param localName The local name of this qualified QName
+ * @return An UnqualifiedQName instance
+ * @throws NullPointerException if any argument is {@code null}
+ * @throws IllegalArgumentException if {@code localName} is not a valid YANG identifier
+ */
+ public static Qualified qualified(final String prefix, final String localName) {
+ return new Qualified(checkLocalName(prefix), checkLocalName(localName));
+ }
+
+ /**
+ * Create a new unqualified unresolved QName.
+ *
+ * @param localName The local name of this unqualified QName
+ * @return An UnqualifiedQName instance
+ * @throws NullPointerException if localName is {@code null}
+ * @throws IllegalArgumentException if {@code localName} is not a valid YANG identifier
+ */
+ public static Unqualified unqualified(final String localName) {
+ return new Unqualified(checkLocalName(localName));
+ }
+
+ /**
+ * Try to create a new unqualified QName.
+ *
+ * @param localName The local name of this unqualified QName
+ * @return An UnqualifiedQName instance, or null if localName is not valid
+ */
+ @SuppressFBWarnings(value = "NP_NONNULL_RETURN_VIOLATION", justification = "Non-grok of @Nullable")
+ public static @Nullable Unqualified tryLocalName(final String localName) {
+ return isValidLocalName(localName) ? new Unqualified(localName) : null;
+ }
+
+ @Override
+ public abstract UnresolvedQName intern();
+
+ /**
+ * Return the prefix of this unresolved QName.
+ *
+ * @return This QName's prefix
+ */
+ public abstract @Nullable String getPrefix();
+}
import java.net.URI;
import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
/**
* Constant definitions present in RFC documents related to the YANG language.
// Dummy template UnqualifiedQName. These are never leaked, but are used for efficient instantiation via
// UnqualifiedQName#bindTo()
- private static final UnqualifiedQName DUMMY_OPERATION_INPUT = UnqualifiedQName.of("input");
- private static final UnqualifiedQName DUMMY_OPERATION_OUTPUT = UnqualifiedQName.of("output");
+ private static final Unqualified DUMMY_OPERATION_INPUT = UnresolvedQName.unqualified("input");
+ private static final Unqualified DUMMY_OPERATION_OUTPUT = UnresolvedQName.unqualified("output");
private YangConstants() {
// Hidden on purpose
import org.opendaylight.yangtools.yang.common.AbstractQName;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.PathExpression;
import org.opendaylight.yangtools.yang.model.api.PathExpression.DerefSteps;
import org.opendaylight.yangtools.yang.model.api.PathExpression.LocationPathSteps;
// where the typedef is referenced. If a typedef is defined and
// referenced within a grouping, the namespace is affected by where
// the grouping is used (see Section 7.13).
- this.leafrefModule = getBaseModule(leafrefType);
- this.nodeModule = currentNode.getQName().getModule();
+ leafrefModule = getBaseModule(leafrefType);
+ nodeModule = currentNode.getQName().getModule();
}
LeafRefPath parseLeafRefPath(final PathExpression path) {
private static QName resolve(final AbstractQName qname, final QNameModule localModule) {
if (qname instanceof QName) {
return (QName) qname;
- } else if (qname instanceof UnqualifiedQName) {
+ } else if (qname instanceof Unqualified) {
// Bind to namespace. Note we expect to perform frequent matching, hence we are interning the result
- return ((UnqualifiedQName) qname).bindTo(localModule).intern();
+ return ((Unqualified) qname).bindTo(localModule).intern();
} else {
throw new IllegalStateException("Unhandled unresolved QName " + qname);
}
package org.opendaylight.yangtools.odlext.model.api;
import com.google.common.annotations.Beta;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.UnknownEffectiveStatement;
@Beta
public interface AugmentIdentifierEffectiveStatement
- extends UnknownEffectiveStatement<UnqualifiedQName, AugmentIdentifierStatement> {
+ extends UnknownEffectiveStatement<Unqualified, AugmentIdentifierStatement> {
@Override
default StatementDefinition statementDefinition() {
return OpenDaylightExtensionsStatements.AUGMENT_IDENTIFIER;
package org.opendaylight.yangtools.odlext.model.api;
import com.google.common.annotations.Beta;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.UnknownStatement;
@Beta
-public interface AugmentIdentifierStatement extends UnknownStatement<UnqualifiedQName> {
+public interface AugmentIdentifierStatement extends UnknownStatement<Unqualified> {
@Override
default StatementDefinition statementDefinition() {
return OpenDaylightExtensionsStatements.AUGMENT_IDENTIFIER;
import com.google.common.annotations.Beta;
import java.util.Collection;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
@Beta
-public interface BodyDeclaredStatement extends NotificationStatementAwareDeclaredStatement<UnqualifiedQName>,
- DataDefinitionAwareDeclaredStatement.WithReusableDefinitions<UnqualifiedQName> {
+public interface BodyDeclaredStatement extends NotificationStatementAwareDeclaredStatement<Unqualified>,
+ DataDefinitionAwareDeclaredStatement.WithReusableDefinitions<Unqualified> {
default @NonNull Collection<? extends ExtensionStatement> getExtensions() {
return declaredSubstatements(ExtensionStatement.class);
}
import com.google.common.annotations.Beta;
import java.util.Collection;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
@Beta
-public interface LinkageDeclaredStatement extends DeclaredStatement<UnqualifiedQName> {
+public interface LinkageDeclaredStatement extends DeclaredStatement<Unqualified> {
default @NonNull Collection<? extends ImportStatement> getImports() {
return declaredSubstatements(ImportStatement.class);
}
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
*/
@Beta
public interface ModuleEffectiveStatement
- extends DataTreeAwareEffectiveStatement<UnqualifiedQName, ModuleStatement>, SchemaTreeRoot {
+ extends DataTreeAwareEffectiveStatement<Unqualified, ModuleStatement>, SchemaTreeRoot {
/**
* Namespace mapping all known prefixes in a module to their modules. Note this namespace includes the module
* in which it is instantiated.
package org.opendaylight.yangtools.yang.model.api.stmt;
import java.util.Optional;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
-public interface ModuleStatement extends MetaDeclaredStatement<UnqualifiedQName>, ModuleHeaderGroup,
+public interface ModuleStatement extends MetaDeclaredStatement<Unqualified>, ModuleHeaderGroup,
LinkageDeclaredStatement, RevisionAwareDeclaredStatement, BodyDeclaredStatement {
@Override
default StatementDefinition statementDefinition() {
import com.google.common.annotations.Beta;
import java.util.Collection;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
@Beta
-public interface RevisionAwareDeclaredStatement extends DeclaredStatement<UnqualifiedQName> {
+public interface RevisionAwareDeclaredStatement extends DeclaredStatement<Unqualified> {
default @NonNull Collection<? extends RevisionStatement> getRevisions() {
return declaredSubstatements(RevisionStatement.class);
}
package org.opendaylight.yangtools.yang.model.api.stmt;
import com.google.common.annotations.Beta;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
*/
@Beta
public interface SubmoduleEffectiveStatement
- extends DataTreeAwareEffectiveStatement<UnqualifiedQName, SubmoduleStatement> {
+ extends DataTreeAwareEffectiveStatement<Unqualified, SubmoduleStatement> {
@Override
default StatementDefinition statementDefinition() {
return YangStmtMapping.SUBMODULE;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
-public interface SubmoduleStatement extends MetaDeclaredStatement<UnqualifiedQName>, LinkageDeclaredStatement,
+public interface SubmoduleStatement extends MetaDeclaredStatement<Unqualified>, LinkageDeclaredStatement,
RevisionAwareDeclaredStatement, BodyDeclaredStatement {
@Override
default StatementDefinition statementDefinition() {
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.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.DeviateKind;
: new RegularModifierStatement(argument, substatements);
}
- public static ModuleStatement createModule(final String rawArgument, final UnqualifiedQName argument,
+ public static ModuleStatement createModule(final String rawArgument, final Unqualified argument,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
return new ModuleStatementImpl(rawArgument, argument, substatements);
}
}
}
- public static SubmoduleStatement createSubmodule(final String rawArgument, final UnqualifiedQName argument,
+ public static SubmoduleStatement createSubmodule(final String rawArgument, final Unqualified argument,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
return new SubmoduleStatementImpl(rawArgument, argument, substatements);
}
package org.opendaylight.yangtools.yang.model.ri.stmt.impl.decl;
import com.google.common.collect.ImmutableList;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.BodyDeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.LinkageDeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionAwareDeclaredStatement;
import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.WithArgument.WithSubstatements;
-abstract class AbstractDeclaredEffectiveRootStatement<D extends DeclaredStatement<UnqualifiedQName>>
- extends WithSubstatements<UnqualifiedQName> implements LinkageDeclaredStatement,
- MetaDeclaredStatement<UnqualifiedQName>, RevisionAwareDeclaredStatement, BodyDeclaredStatement {
- protected AbstractDeclaredEffectiveRootStatement(final String rawArgument, final UnqualifiedQName argument,
+abstract class AbstractDeclaredEffectiveRootStatement<D extends DeclaredStatement<Unqualified>>
+ extends WithSubstatements<Unqualified> implements LinkageDeclaredStatement,
+ MetaDeclaredStatement<Unqualified>, RevisionAwareDeclaredStatement, BodyDeclaredStatement {
+ protected AbstractDeclaredEffectiveRootStatement(final String rawArgument, final Unqualified argument,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
super(rawArgument, argument, substatements);
}
package org.opendaylight.yangtools.yang.model.ri.stmt.impl.decl;
import com.google.common.collect.ImmutableList;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement;
public final class ModuleStatementImpl extends AbstractDeclaredEffectiveRootStatement<ModuleStatement>
implements ModuleStatement {
- public ModuleStatementImpl(final String rawArgument, final UnqualifiedQName argument,
+ public ModuleStatementImpl(final String rawArgument, final Unqualified argument,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
super(rawArgument, argument, substatements);
}
package org.opendaylight.yangtools.yang.model.ri.stmt.impl.decl;
import com.google.common.collect.ImmutableList;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
public final class SubmoduleStatementImpl extends AbstractDeclaredEffectiveRootStatement<SubmoduleStatement>
implements SubmoduleStatement {
- public SubmoduleStatementImpl(final String rawArgument, final UnqualifiedQName argument,
+ public SubmoduleStatementImpl(final String rawArgument, final Unqualified argument,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
super(rawArgument, argument, substatements);
}
*/
package org.opendaylight.yangtools.yang.model.ri.stmt.impl.ref;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference;
import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement;
import org.opendaylight.yangtools.yang.model.spi.meta.AbstractRefStatement;
-public final class RefModuleStatement extends AbstractRefStatement<UnqualifiedQName, ModuleStatement>
+public final class RefModuleStatement extends AbstractRefStatement<Unqualified, ModuleStatement>
implements ModuleStatement {
public RefModuleStatement(final ModuleStatement delegate, final DeclarationReference ref) {
super(delegate, ref);
*/
package org.opendaylight.yangtools.yang.model.ri.stmt.impl.ref;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference;
import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
import org.opendaylight.yangtools.yang.model.spi.meta.AbstractRefStatement;
-public final class RefSubmoduleStatement extends AbstractRefStatement<UnqualifiedQName, SubmoduleStatement>
+public final class RefSubmoduleStatement extends AbstractRefStatement<Unqualified, SubmoduleStatement>
implements SubmoduleStatement {
public RefSubmoduleStatement(final SubmoduleStatement delegate, final DeclarationReference ref) {
super(delegate, ref);
import org.opendaylight.yangtools.yang.common.AbstractQName;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextProvider;
import org.opendaylight.yangtools.yang.model.api.EffectiveStatementInference;
private boolean clean;
private SchemaInferenceStack(final EffectiveModelContext effectiveModel, final int expectedSize) {
- this.deque = new ArrayDeque<>(expectedSize);
+ deque = new ArrayDeque<>(expectedSize);
this.effectiveModel = requireNonNull(effectiveModel);
- this.clean = true;
+ clean = true;
}
private SchemaInferenceStack(final SchemaInferenceStack source) {
- this.deque = source.deque.clone();
- this.effectiveModel = source.effectiveModel;
- this.currentModule = source.currentModule;
- this.groupingDepth = source.groupingDepth;
- this.clean = source.clean;
+ deque = source.deque.clone();
+ effectiveModel = source.effectiveModel;
+ currentModule = source.currentModule;
+ groupingDepth = source.groupingDepth;
+ clean = source.clean;
}
private SchemaInferenceStack(final EffectiveModelContext effectiveModel,
private SchemaInferenceStack(final EffectiveModelContext effectiveModel) {
this.effectiveModel = requireNonNull(effectiveModel);
- this.deque = new ArrayDeque<>();
- this.clean = true;
+ deque = new ArrayDeque<>();
+ clean = true;
}
/**
final QName qname;
if (toResolve instanceof QName) {
qname = (QName) toResolve;
- } else if (toResolve instanceof UnqualifiedQName) {
+ } else if (toResolve instanceof Unqualified) {
checkArgument(defaultNamespace != null, "Can not find target module of step %s", step);
- qname = ((UnqualifiedQName) toResolve).bindTo(defaultNamespace);
+ qname = ((Unqualified) toResolve).bindTo(defaultNamespace);
} else {
throw new VerifyException("Unexpected child step QName " + toResolve);
}
import com.google.common.collect.ImmutableList;
import org.opendaylight.yangtools.odlext.model.api.AugmentIdentifierEffectiveStatement;
import org.opendaylight.yangtools.odlext.model.api.AugmentIdentifierStatement;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements;
-final class AugmentIdentifierEffectiveStatementImpl
- extends WithSubstatements<UnqualifiedQName, AugmentIdentifierStatement>
+final class AugmentIdentifierEffectiveStatementImpl extends WithSubstatements<Unqualified, AugmentIdentifierStatement>
implements AugmentIdentifierEffectiveStatement {
AugmentIdentifierEffectiveStatementImpl(final AugmentIdentifierStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
import com.google.common.collect.ImmutableList;
import org.opendaylight.yangtools.odlext.model.api.AugmentIdentifierStatement;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.spi.meta.AbstractDeclaredStatement.WithArgument.WithSubstatements;
-final class AugmentIdentifierStatementImpl extends WithSubstatements<UnqualifiedQName>
+final class AugmentIdentifierStatementImpl extends WithSubstatements<Unqualified>
implements AugmentIdentifierStatement {
- AugmentIdentifierStatementImpl(final UnqualifiedQName argument,
+ AugmentIdentifierStatementImpl(final Unqualified argument,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
super(argument.getLocalName(), argument, substatements);
}
import org.opendaylight.yangtools.odlext.model.api.AugmentIdentifierEffectiveStatement;
import org.opendaylight.yangtools.odlext.model.api.AugmentIdentifierStatement;
import org.opendaylight.yangtools.odlext.model.api.OpenDaylightExtensionsStatements;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
@Beta
public final class AugmentIdentifierStatementSupport
- extends AbstractStatementSupport<UnqualifiedQName, AugmentIdentifierStatement,
- AugmentIdentifierEffectiveStatement> {
+ extends AbstractStatementSupport<Unqualified, AugmentIdentifierStatement, AugmentIdentifierEffectiveStatement> {
private static final SubstatementValidator VALIDATOR =
SubstatementValidator.builder(OpenDaylightExtensionsStatements.AUGMENT_IDENTIFIER).build();
}
@Override
- public UnqualifiedQName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ public Unqualified parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
try {
- return UnqualifiedQName.of(value).intern();
+ return UnresolvedQName.unqualified(value).intern();
} catch (IllegalArgumentException e) {
throw new SourceException(ctx, e, "Invalid identifier \"%s\"", value);
}
@Override
protected AugmentIdentifierStatement createDeclared(
- final StmtContext<UnqualifiedQName, AugmentIdentifierStatement, ?> ctx,
+ final StmtContext<Unqualified, AugmentIdentifierStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
return new AugmentIdentifierStatementImpl(ctx.getArgument(), substatements);
}
@Override
protected AugmentIdentifierEffectiveStatement createEffective(
- final Current<UnqualifiedQName, AugmentIdentifierStatement> stmt,
+ final Current<Unqualified, AugmentIdentifierStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return new AugmentIdentifierEffectiveStatementImpl(stmt.declared(), substatements);
}
package org.opendaylight.yangtools.odlext.parser;
import org.opendaylight.yangtools.odlext.model.api.AugmentIdentifierStatement;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference;
import org.opendaylight.yangtools.yang.model.spi.meta.AbstractRefStatement;
-final class RefAugmentIdentifierStatement extends AbstractRefStatement<UnqualifiedQName, AugmentIdentifierStatement>
+final class RefAugmentIdentifierStatement extends AbstractRefStatement<Unqualified, AugmentIdentifierStatement>
implements AugmentIdentifierStatement {
RefAugmentIdentifierStatement(final AugmentIdentifierStatement delegate, final DeclarationReference ref) {
super(delegate, ref);
import org.opendaylight.yangtools.concepts.SemVer;
import org.opendaylight.yangtools.openconfig.model.api.OpenConfigVersionEffectiveStatement;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
@Beta
-public abstract class AbstractEffectiveModule<D extends DeclaredStatement<UnqualifiedQName>,
- E extends DataTreeAwareEffectiveStatement<UnqualifiedQName, D>>
- extends WithTypedefNamespace<UnqualifiedQName, D, E>
- implements ModuleLike, DocumentedNodeMixin<UnqualifiedQName, D>,
- NotificationNodeContainerCompat<UnqualifiedQName, D, E> {
+public abstract class AbstractEffectiveModule<D extends DeclaredStatement<Unqualified>,
+ E extends DataTreeAwareEffectiveStatement<Unqualified, D>>
+ extends WithTypedefNamespace<Unqualified, D, E>
+ implements ModuleLike, DocumentedNodeMixin<Unqualified, D>, NotificationNodeContainerCompat<Unqualified, D, E> {
private final String prefix;
private final ImmutableSet<GroupingDefinition> groupings;
private final ImmutableSet<UsesNode> uses;
private final ImmutableSet<TypeDefinition<?>> typeDefinitions;
- protected AbstractEffectiveModule(final Current<UnqualifiedQName, D> stmt,
+ protected AbstractEffectiveModule(final Current<Unqualified, D> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final String prefix) {
super(stmt.declared(), substatements);
}
@Override
- public UnqualifiedQName argument() {
+ public Unqualified argument() {
return getDeclared().argument();
}
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.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.Submodule;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
private final @NonNull QNameModule qnameModule;
private final ImmutableList<Submodule> submodules;
- ModuleEffectiveStatementImpl(final Current<UnqualifiedQName, ModuleStatement> stmt,
+ ModuleEffectiveStatementImpl(final Current<Unqualified, ModuleStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
final Collection<? extends Submodule> submodules, final QNameModule qnameModule) {
super(stmt, substatements, findPrefix(stmt, substatements, "module", stmt.getRawArgument()));
import org.opendaylight.yangtools.yang.common.Empty;
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.UnresolvedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
@Beta
public final class ModuleStatementSupport
- extends AbstractStatementSupport<UnqualifiedQName, ModuleStatement, ModuleEffectiveStatement> {
+ extends AbstractStatementSupport<Unqualified, ModuleStatement, ModuleEffectiveStatement> {
private static final SubstatementValidator RFC6020_VALIDATOR = SubstatementValidator.builder(YangStmtMapping.MODULE)
.addAny(YangStmtMapping.ANYXML)
.addAny(YangStmtMapping.AUGMENT)
}
@Override
- public UnqualifiedQName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ public Unqualified parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
try {
- return UnqualifiedQName.of(value);
+ return UnresolvedQName.unqualified(value);
} catch (IllegalArgumentException e) {
throw new SourceException(e.getMessage(), ctx, e);
}
}
@Override
- public void onPreLinkageDeclared(final Mutable<UnqualifiedQName, ModuleStatement, ModuleEffectiveStatement> stmt) {
+ public void onPreLinkageDeclared(final Mutable<Unqualified, ModuleStatement, ModuleEffectiveStatement> stmt) {
final String moduleName = stmt.getRawArgument();
final XMLNamespace moduleNs = SourceException.throwIfNull(
}
@Override
- public void onLinkageDeclared(final Mutable<UnqualifiedQName, ModuleStatement, ModuleEffectiveStatement> stmt) {
+ public void onLinkageDeclared(final Mutable<Unqualified, ModuleStatement, ModuleEffectiveStatement> stmt) {
final XMLNamespace moduleNs = SourceException.throwIfNull(
firstAttributeOf(stmt.declaredSubstatements(), NamespaceStatement.class), stmt,
"Namespace of the module [%s] is missing", stmt.argument());
@Override
protected ImmutableList<? extends EffectiveStatement<?, ?>> buildEffectiveSubstatements(
- final Current<UnqualifiedQName, ModuleStatement> stmt,
+ final Current<Unqualified, ModuleStatement> stmt,
final List<? extends StmtContext<?, ?, ?>> substatements) {
final ImmutableList<? extends EffectiveStatement<?, ?>> local =
super.buildEffectiveSubstatements(stmt, substatements);
}
@Override
- protected ModuleStatement createDeclared(final StmtContext<UnqualifiedQName, ModuleStatement, ?> ctx,
+ protected ModuleStatement createDeclared(final StmtContext<Unqualified, ModuleStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
if (substatements.isEmpty()) {
throw noNamespace(ctx);
}
@Override
- protected ModuleEffectiveStatement createEffective(final Current<UnqualifiedQName, ModuleStatement> stmt,
+ protected ModuleEffectiveStatement createEffective(final Current<Unqualified, ModuleStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
if (substatements.isEmpty()) {
throw noNamespace(stmt);
}
private static void addToSemVerModuleNamespace(
- final Mutable<UnqualifiedQName, ModuleStatement, ModuleEffectiveStatement> stmt,
+ final Mutable<Unqualified, ModuleStatement, ModuleEffectiveStatement> stmt,
final SourceIdentifier moduleIdentifier) {
final SemVerSourceIdentifier id = SemVerSourceIdentifier.create(stmt.getRawArgument(),
stmt.getFromNamespace(SemanticVersionNamespace.class, stmt));
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.tree.ParseTree;
import org.antlr.v4.runtime.tree.TerminalNode;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName;
import org.opendaylight.yangtools.yang.model.api.PathExpression;
import org.opendaylight.yangtools.yang.model.api.PathExpression.DerefSteps;
import org.opendaylight.yangtools.yang.model.api.PathExpression.LocationPathSteps;
private static YangQNameExpr createChildExpr(final StmtContext<?, ?, ?> ctx, final Node_identifierContext qname) {
switch (qname.getChildCount()) {
case 1:
- return YangQNameExpr.of(UnqualifiedQName.of(qname.getText()).intern());
+ return YangQNameExpr.of(UnresolvedQName.unqualified(qname.getText()).intern());
case 3:
return YangQNameExpr.of(parseQName(ctx, qname));
default:
final List<YangExpr> predicates) {
switch (qname.getChildCount()) {
case 1:
- return YangXPathAxis.CHILD.asStep(UnqualifiedQName.of(qname.getText()).intern(), predicates);
+ return YangXPathAxis.CHILD.asStep(UnresolvedQName.unqualified(qname.getText()).intern(), predicates);
case 3:
return YangXPathAxis.CHILD.asStep(parseQName(ctx, qname), predicates);
default:
}
}
- private static QName parseQName(final StmtContext<?, ?, ?> ctx, final Node_identifierContext qname) {
+ private static @NonNull QName parseQName(final StmtContext<?, ?, ?> ctx, final Node_identifierContext qname) {
return StmtContextUtils.parseNodeIdentifier(ctx, qname.getChild(0).getText(), qname.getChild(2).getText());
}
}
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.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.Submodule;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
private ImmutableSet<Submodule> submodules;
private boolean sealed;
- SubmoduleEffectiveStatementImpl(final Current<UnqualifiedQName, SubmoduleStatement> stmt,
+ SubmoduleEffectiveStatementImpl(final Current<Unqualified, SubmoduleStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements, findSubmodulePrefix(stmt, substatements));
final Optional<Revision> submoduleRevision = findFirstEffectiveSubstatementArgument(
RevisionEffectiveStatement.class);
- this.qnameModule = QNameModule.create(belongsToModuleQName.getNamespace(), submoduleRevision).intern();
+ qnameModule = QNameModule.create(belongsToModuleQName.getNamespace(), submoduleRevision).intern();
/*
* Because of possible circular chains of includes between submodules we can
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclarationReference;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
@Beta
public final class SubmoduleStatementSupport
- extends AbstractStatementSupport<UnqualifiedQName, SubmoduleStatement, SubmoduleEffectiveStatement> {
+ extends AbstractStatementSupport<Unqualified, SubmoduleStatement, SubmoduleEffectiveStatement> {
private static final SubstatementValidator RFC6020_VALIDATOR =
SubstatementValidator.builder(YangStmtMapping.SUBMODULE)
.addAny(YangStmtMapping.ANYXML)
}
@Override
- public UnqualifiedQName parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
+ public Unqualified parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
try {
- return UnqualifiedQName.of(value);
+ return UnresolvedQName.unqualified(value);
} catch (IllegalArgumentException e) {
throw new SourceException(e.getMessage(), ctx, e);
}
}
@Override
- public void onPreLinkageDeclared(
- final Mutable<UnqualifiedQName, SubmoduleStatement, SubmoduleEffectiveStatement> stmt) {
+ public void onPreLinkageDeclared(final Mutable<Unqualified, SubmoduleStatement, SubmoduleEffectiveStatement> stmt) {
stmt.setRootIdentifier(RevisionSourceIdentifier.create(stmt.getRawArgument(),
StmtContextUtils.getLatestRevision(stmt.declaredSubstatements())));
}
@Override
- public void onLinkageDeclared(
- final Mutable<UnqualifiedQName, SubmoduleStatement, SubmoduleEffectiveStatement> stmt) {
+ public void onLinkageDeclared(final Mutable<Unqualified, SubmoduleStatement, SubmoduleEffectiveStatement> stmt) {
final SourceIdentifier submoduleIdentifier = RevisionSourceIdentifier.create(stmt.getRawArgument(),
StmtContextUtils.getLatestRevision(stmt.declaredSubstatements()));
}
@Override
- protected SubmoduleStatement createDeclared(final StmtContext<UnqualifiedQName, SubmoduleStatement, ?> ctx,
+ protected SubmoduleStatement createDeclared(final StmtContext<Unqualified, SubmoduleStatement, ?> ctx,
final ImmutableList<? extends DeclaredStatement<?>> substatements) {
if (substatements.isEmpty()) {
throw noBelongsTo(ctx);
}
@Override
- protected SubmoduleEffectiveStatement createEffective(final Current<UnqualifiedQName, SubmoduleStatement> stmt,
+ protected SubmoduleEffectiveStatement createEffective(final Current<Unqualified, SubmoduleStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
if (substatements.isEmpty()) {
throw noBelongsTo(stmt);
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName;
import org.opendaylight.yangtools.yang.model.api.PathExpression;
import org.opendaylight.yangtools.yang.model.api.PathExpression.DerefSteps;
import org.opendaylight.yangtools.yang.model.api.PathExpression.LocationPathSteps;
final DerefSteps derefSteps = (DerefSteps) steps;
assertEquals(YangLocationPath.relative(YangXPathAxis.PARENT.asStep(),
- YangXPathAxis.CHILD.asStep(UnqualifiedQName.of("type"))), derefSteps.getRelativePath());
+ YangXPathAxis.CHILD.asStep(UnresolvedQName.unqualified("type"))), derefSteps.getRelativePath());
assertEquals(YangLocationPath.relative(YangXPathAxis.PARENT.asStep(),
- YangXPathAxis.CHILD.asStep(UnqualifiedQName.of("id"))), derefSteps.getDerefArgument());
+ YangXPathAxis.CHILD.asStep(UnresolvedQName.unqualified("id"))), derefSteps.getDerefArgument());
}
@Test
path.getSteps();
assertEquals(ImmutableList.of(
- YangXPathAxis.CHILD.asStep(UnqualifiedQName.of("device_types")),
- YangXPathAxis.CHILD.asStep(UnqualifiedQName.of("device_type"),
+ YangXPathAxis.CHILD.asStep(UnresolvedQName.unqualified("device_types")),
+ YangXPathAxis.CHILD.asStep(UnresolvedQName.unqualified("device_type"),
ImmutableSet.of(YangBinaryOperator.EQUALS.exprWith(
- YangQNameExpr.of(UnqualifiedQName.of("type")),
+ YangQNameExpr.of(UnresolvedQName.unqualified("type")),
YangPathExpr.of(YangFunctionCallExpr.of(YangFunction.CURRENT.getIdentifier()), Relative.relative(
YangXPathAxis.PARENT.asStep(),
- YangXPathAxis.CHILD.asStep(UnqualifiedQName.of("type_text"))))))),
- YangXPathAxis.CHILD.asStep(UnqualifiedQName.of("desc"))), path.getSteps());
+ YangXPathAxis.CHILD.asStep(UnresolvedQName.unqualified("type_text"))))))),
+ YangXPathAxis.CHILD.asStep(UnresolvedQName.unqualified("desc"))), path.getSteps());
}
}
import org.opendaylight.yangtools.yang.common.AbstractQName;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName;
@Beta
public abstract class YangLocationPath implements YangExpr {
}
}
- public static class UnresolvedQNameStep extends AbstractQNameStep<AbstractQName>
+ public static class UnresolvedQNameStep extends AbstractQNameStep<UnresolvedQName>
implements UnresolvedQNameReferent<ResolvedQNameStep> {
private static final long serialVersionUID = 1L;
- UnresolvedQNameStep(final YangXPathAxis axis, final AbstractQName qname) {
+ UnresolvedQNameStep(final YangXPathAxis axis, final UnresolvedQName qname) {
super(axis, qname);
}
- static UnresolvedQNameStep of(final YangXPathAxis axis, final AbstractQName qname,
+ static UnresolvedQNameStep of(final YangXPathAxis axis, final UnresolvedQName qname,
final Collection<YangExpr> predicates) {
return predicates.isEmpty() ? new UnresolvedQNameStep(axis, qname)
: new UnresolvedQNameStepWithPredicates(axis, qname, ImmutableSet.copyOf(predicates));
private final ImmutableSet<YangExpr> predicates;
- UnresolvedQNameStepWithPredicates(final YangXPathAxis axis, final AbstractQName qname,
+ UnresolvedQNameStepWithPredicates(final YangXPathAxis axis, final UnresolvedQName qname,
final ImmutableSet<YangExpr> predicates) {
super(axis, qname);
this.predicates = requireNonNull(predicates);
import com.google.common.annotations.Beta;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.yang.common.AbstractQName;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName;
/**
* An XPath QName expression. This is an exact QName, which cannot be converted to a string literal compatible with
public static final class Unresolved extends YangQNameExpr implements UnresolvedQNameReferent<Resolved> {
private static final long serialVersionUID = 1L;
- private final AbstractQName qname;
+ private final UnresolvedQName qname;
- Unresolved(final AbstractQName qname) {
+ Unresolved(final UnresolvedQName qname) {
this.qname = requireNonNull(qname);
}
@Override
- public AbstractQName getQName() {
+ public UnresolvedQName getQName() {
return qname;
}
// Prevent instantiation
}
- public static Unresolved of(final AbstractQName qname) {
+ public static Unresolved of(final UnresolvedQName qname) {
return new Unresolved(qname);
}
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableSet;
import java.util.Collection;
-import org.opendaylight.yangtools.yang.common.AbstractQName;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName;
import org.opendaylight.yangtools.yang.xpath.api.YangLocationPath.AxisStep;
import org.opendaylight.yangtools.yang.xpath.api.YangLocationPath.AxisStepWithPredicates;
import org.opendaylight.yangtools.yang.xpath.api.YangLocationPath.NodeTypeStep;
return ResolvedQNameStep.of(this, qname, predicates);
}
- public final UnresolvedQNameStep asStep(final AbstractQName qname) {
+ public final UnresolvedQNameStep asStep(final UnresolvedQName qname) {
return new UnresolvedQNameStep(this, qname);
}
- public final UnresolvedQNameStep asStep(final AbstractQName qname, final Collection<YangExpr> predicates) {
+ public final UnresolvedQNameStep asStep(final UnresolvedQName qname, final Collection<YangExpr> predicates) {
return UnresolvedQNameStep.of(this, qname, predicates);
}
import javax.xml.xpath.XPathExpressionException;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.common.QualifiedQName;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Qualified;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.common.YangVersion;
/**
* levels to which an XPath expression can be bound:
* <ul>
* <li>Unbound Expressions, which is a essentially a parse tree. No namespace binding has been performed, i.e. all
- * node identifiers are in {@link QualifiedQName} or {@link UnqualifiedQName} form. This level is typically not used
- * when dealing with YANG models directly, but can be useful for validating a String conforms to XPath syntax.
+ * node identifiers are in {@link Qualified} or {@link Unqualified} form. This level is typically not used when
+ * dealing with YANG models directly, but can be useful for validating a String conforms to XPath syntax.
* </li>
- * <li>Qualified-bound Expressions, where all {@link QualifiedQName}s are resolved and bound to {@link QName}s, but
- * {@link UnqualifiedQName}s are still present. This level corresponds to how far a YANG parser can interpret XPath
+ * <li>Qualified-bound Expressions, where all {@link Qualified}s are resolved and bound to {@link QName}s, but
+ * {@link Unqualified}s are still present. This level corresponds to how far a YANG parser can interpret XPath
* expressions defined in {@code typedef} statements and statements which are not fully instantiated, i.e. are
* descendants of a {@code grouping} statement.
* </li>
@Beta
public interface YangXPathExpression extends Immutable {
/**
- * A Qualified-bound expression. All {@link QualifiedQName}s are eliminated and replaced with {@link QName}s.
+ * A Qualified-bound expression. All {@link Qualified}s are eliminated and replaced with {@link QName}s.
*/
interface QualifiedBound extends YangXPathExpression {
}
+ /**
+ * An Unqualified-bound expression. All {@link Unqualified}s are eliminated and replaced with {@link QName}s.
+ */
interface UnqualifiedBound extends QualifiedBound {
@Override
YangQNameExpr.Resolved interpretAsQName(YangLiteralExpr expr) throws XPathExpressionException;
import org.antlr.v4.runtime.tree.TerminalNode;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.common.QualifiedQName;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName;
import org.opendaylight.yangtools.yang.common.YangConstants;
import org.opendaylight.yangtools.yang.common.YangNamespaceContext;
import org.opendaylight.yangtools.yang.common.YangVersion;
@Override
QNameStep createStep(final YangXPathAxis axis, final String localName,
final List<YangExpr> predicates) {
- return axis.asStep(UnqualifiedQName.of(localName).intern(), predicates);
+ return axis.asStep(UnresolvedQName.unqualified(localName).intern(), predicates);
}
@Override
QNameStep createStep(final YangXPathAxis axis, final String prefix, final String localName,
final List<YangExpr> predicates) {
- return axis.asStep(QualifiedQName.of(prefix, localName).intern(), predicates);
+ return axis.asStep(UnresolvedQName.qualified(prefix, localName).intern(), predicates);
}
@Override
AntlrXPathParser(final YangXPathMathMode mathMode) {
this.mathMode = requireNonNull(mathMode);
- this.mathSupport = mathMode.getSupport();
- this.functionSupport = new FunctionSupport(mathSupport);
+ mathSupport = mathMode.getSupport();
+ functionSupport = new FunctionSupport(mathSupport);
}
abstract QName createQName(String localName);
import org.antlr.v4.runtime.CharStreams;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.tree.ParseTree;
-import org.opendaylight.yangtools.yang.common.QualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName;
import org.opendaylight.yangtools.yang.common.YangNamespaceContext;
import org.opendaylight.yangtools.yang.xpath.antlr.instanceIdentifierParser;
import org.opendaylight.yangtools.yang.xpath.antlr.instanceIdentifierParser.EqQuotedStringContext;
@Override
YangQNameExpr createExpr(final String prefix, final String localName) {
- return YangQNameExpr.of(QualifiedQName.of(prefix, localName));
+ return YangQNameExpr.of(UnresolvedQName.qualified(prefix, localName));
}
@Override
QNameStep createChildStep(final String prefix, final String localName, final Collection<YangExpr> predicates) {
- return YangXPathAxis.CHILD.asStep(QualifiedQName.of(prefix, localName), predicates);
+ return YangXPathAxis.CHILD.asStep(UnresolvedQName.qualified(prefix, localName), predicates);
}
}
private final YangXPathMathSupport mathSupport;
InstanceIdentifierParser(final YangXPathMathMode mathMode) {
- this.mathSupport = mathMode.getSupport();
+ mathSupport = mathMode.getSupport();
}
final Absolute interpretAsInstanceIdentifier(final YangLiteralExpr expr) throws XPathExpressionException {
import javax.xml.xpath.XPathExpressionException;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.yang.common.AbstractQName;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.common.QualifiedQName;
-import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName;
import org.opendaylight.yangtools.yang.common.YangNamespaceContext;
import org.opendaylight.yangtools.yang.xpath.api.YangLiteralExpr;
import org.opendaylight.yangtools.yang.xpath.api.YangQNameExpr;
final String text = expr.getLiteral();
final int colon = text.indexOf(':');
- final AbstractQName qname;
+ final UnresolvedQName qname;
try {
- qname = colon != -1 ? QualifiedQName.of(text.substring(0, colon), text.substring(colon + 1))
- : UnqualifiedQName.of(text);
+ qname = colon != -1 ? UnresolvedQName.qualified(text.substring(0, colon), text.substring(colon + 1))
+ : UnresolvedQName.unqualified(text);
} catch (IllegalArgumentException e) {
throw wrapException(e, "Cannot interpret %s as a QName", expr);
}
final int colon = text.indexOf(':');
try {
if (colon == -1) {
- return YangQNameExpr.of(UnqualifiedQName.of(text).intern());
+ return YangQNameExpr.of(UnresolvedQName.unqualified(text).intern());
}
return YangQNameExpr.of(namespaceContext.createQName(text.substring(0, colon), text.substring(colon + 1)));
Code Review / yangtools.git / commitdiff