import java.util.Collection;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
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;
/**
* @author Robert Varga
*/
public final class OpenDaylightExtensionsConstants {
- private static final String MODULE_NAME = "yang-ext";
+ private static final Unqualified MODULE_NAME = Unqualified.of("yang-ext").intern();
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");
/**
* Baseline model source name.
*/
- public static final SourceIdentifier ORIGINAL_SOURCE = RevisionSourceIdentifier.create(MODULE_NAME,
- ORIGINAL_REVISION);
+ public static final SourceIdentifier ORIGINAL_SOURCE = new SourceIdentifier(MODULE_NAME, ORIGINAL_REVISION);
private OpenDaylightExtensionsConstants() {
// Hidden on purpose
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.UnresolvedQName.Unqualified;
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 OpenConfigConstants {
- private static final String MODULE_NAME = "yang-ext";
+ private static final Unqualified MODULE_NAME = Unqualified.of("yang-ext").intern();
// Package-visible, because openconfig-version applies across all known revisions and needs to bind to all of them
static final XMLNamespace MODULE_NAMESPACE = XMLNamespace.of("http://openconfig.net/yang/openconfig-ext").intern();
/**
* Original model source name.
*/
- public static final SourceIdentifier SEMVER_SOURCE = RevisionSourceIdentifier.create(MODULE_NAME,
- SEMVER_REVISION);
+ public static final SourceIdentifier SEMVER_SOURCE = new SourceIdentifier(MODULE_NAME, SEMVER_REVISION);
/**
* Original model source name.
*/
- public static final SourceIdentifier ENCRYPTED_VALUE_SOURCE = RevisionSourceIdentifier.create(MODULE_NAME,
+ public static final SourceIdentifier ENCRYPTED_VALUE_SOURCE = new SourceIdentifier(MODULE_NAME,
ENCRYPTED_VALUE_REVISION);
/**
* Original model source name.
*/
- public static final SourceIdentifier HASHED_VALUE_SOURCE = RevisionSourceIdentifier.create(MODULE_NAME,
- HASHED_VALUE_REVISION);
+ public static final SourceIdentifier HASHED_VALUE_SOURCE = new SourceIdentifier(MODULE_NAME, HASHED_VALUE_REVISION);
/**
* Original model source name.
*/
- public static final SourceIdentifier REGEXP_POSIX_SOURCE = RevisionSourceIdentifier.create(MODULE_NAME,
- REGEXP_POSIX_REVISION);
+ public static final SourceIdentifier REGEXP_POSIX_SOURCE = new SourceIdentifier(MODULE_NAME, REGEXP_POSIX_REVISION);
+
/**
* Normative prefix to use when importing {@link #SEMVER_SOURCE} and later.
*/
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.UnresolvedQName.Unqualified;
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
@NonNullByDefault
public final class NetconfConstants {
- private static final String MODULE_NAME = "ietf-netconf";
+ private static final Unqualified MODULE_NAME = Unqualified.of("ietf-netconf").intern();
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");
/**
* RFC6241 model source name.
*/
- public static final SourceIdentifier RFC6241_SOURCE = RevisionSourceIdentifier.create(MODULE_NAME,
- RFC6241_REVISION);
+ public static final SourceIdentifier RFC6241_SOURCE = new SourceIdentifier(MODULE_NAME, RFC6241_REVISION);
/**
* Normative prefix to use when importing {@link #RFC6241_SOURCE}.
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.UnresolvedQName.Unqualified;
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 Unqualified MODULE_NAME = Unqualified.of("ietf-netconf-acm").intern();
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");
/**
* RFC6536 model source name.
*/
- public static final SourceIdentifier RFC6536_SOURCE = RevisionSourceIdentifier.create(MODULE_NAME,
- RFC6536_REVISION);
+ public static final SourceIdentifier RFC6536_SOURCE = new SourceIdentifier(MODULE_NAME, RFC6536_REVISION);
/**
* RFC8341 model source name.
*/
- public static final SourceIdentifier RFC8341_SOURCE = RevisionSourceIdentifier.create(MODULE_NAME,
- RFC8341_REVISION);
+ public static final SourceIdentifier RFC8341_SOURCE = new SourceIdentifier(MODULE_NAME, RFC8341_REVISION);
/**
* Normative prefix to use when importing {@link #RFC6536_SOURCE}.
import java.util.Collection;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
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 Unqualified MODULE_NAME = Unqualified.of("ietf-yang-smiv2").intern();
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");
/**
* RFC6643 model source name.
*/
- public static final SourceIdentifier RFC6643_SOURCE = RevisionSourceIdentifier.create(MODULE_NAME,
- RFC6643_REVISION);
+ public static final SourceIdentifier RFC6643_SOURCE = new SourceIdentifier(MODULE_NAME, RFC6643_REVISION);
/**
* Normative prefix to use when importing {@link #RFC6643_SOURCE}.
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.UnresolvedQName.Unqualified;
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 Unqualified MODULE_NAME = Unqualified.of("ietf-yang-metadata").intern();
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");
/**
* RFC7952 model source name.
*/
- public static final SourceIdentifier RFC7952_SOURCE = RevisionSourceIdentifier.create(MODULE_NAME,
- RFC7952_REVISION);
+ public static final SourceIdentifier RFC7952_SOURCE = new SourceIdentifier(MODULE_NAME, RFC7952_REVISION);
/**
* Normative prefix to use when importing {@link #RFC7952_SOURCE}.
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.UnresolvedQName.Unqualified;
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 Unqualified MODULE_NAME = Unqualified.of("ietf-restconf").intern();
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");
/**
* RFC8040 model source name.
*/
- public static final SourceIdentifier RFC8040_SOURCE = RevisionSourceIdentifier.create(MODULE_NAME,
- RFC8040_REVISION);
+ public static final SourceIdentifier RFC8040_SOURCE = new SourceIdentifier(MODULE_NAME, RFC8040_REVISION);
/**
* Normative prefix to use when importing {@link #RFC8040_SOURCE}.
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.UnresolvedQName.Unqualified;
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 Unqualified MODULE_NAME = Unqualified.of("ietf-yang-schema-mount").intern();
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");
/**
* RFC8528 model source name.
*/
- public static final SourceIdentifier RFC8528_SOURCE = RevisionSourceIdentifier.create(MODULE_NAME,
- RFC8528_REVISION);
+ public static final SourceIdentifier RFC8528_SOURCE = new SourceIdentifier(MODULE_NAME, RFC8528_REVISION);
/**
* Normative prefix to use when importing {@link #RFC8528_SOURCE}.
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.UnresolvedQName.Unqualified;
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 SubscribedNotificationsConstants {
- private static final String MODULE_NAME = "ietf-subscribed-notifications";
+ private static final Unqualified MODULE_NAME = Unqualified.of("ietf-subscribed-notifications").intern();
private static final XMLNamespace MODULE_NAMESPACE =
XMLNamespace.of("urn:ietf:params:xml:ns:yang:ietf-subscribed-notifications").intern();
private static final Revision RFC8639_REVISION = Revision.of("2019-09-09");
/**
* RFC8639 model source name.
*/
- public static final SourceIdentifier RFC8639_SOURCE = RevisionSourceIdentifier.create(MODULE_NAME,
- RFC8639_REVISION);
+ public static final SourceIdentifier RFC8639_SOURCE = new SourceIdentifier(MODULE_NAME, RFC8639_REVISION);
/**
* Normative prefix to use when importing {@link #RFC8639_SOURCE}.
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.stmt.ImportEffectiveStatement;
/**
*
* @return Name of the module to import
*/
- default @NonNull String getModuleName() {
- return asEffectiveStatement().argument().getLocalName();
+ default @NonNull Unqualified getModuleName() {
+ return asEffectiveStatement().argument();
}
/**
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
final @NonNull SourceIdentifier importedSource) {
super(declared, substatements);
- revision = importedSource.getRevision().orElse(null);
+ revision = importedSource.revision();
}
@Override
// no need to check if other Type of object, check is performed in process modules
for (final ModuleImport imprt : allImports(module)) {
- final String toName = imprt.getModuleName();
+ final String toName = imprt.getModuleName().getLocalName();
final Optional<Revision> toRevision = imprt.getRevision();
final ModuleNodeImpl from = moduleGraph.get(fromName, fromRevision);
ModuleNodeImpl(final String name, final Revision revision, final Module module) {
this.name = name;
this.revision = revision;
- this.originalObject = module;
+ originalObject = module;
}
String getName() {
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.yangtools.yang.common.QNameModule;
+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.Module;
doReturn(Set.of()).when(fooNoRev).getImports();
doReturn(Set.of()).when(fooNoRev).getSubmodules();
- doReturn("foo").when(fooNoRevImport).getModuleName();
+ doReturn(Unqualified.of("foo")).when(fooNoRevImport).getModuleName();
doReturn(Optional.empty()).when(fooNoRevImport).getRevision();
doReturn("bar").when(bar).getName();
*/
package org.opendaylight.yangtools.yang.model.util;
-import static com.google.common.base.Preconditions.checkArgument;
import static java.util.Objects.requireNonNull;
import com.google.common.base.Preconditions;
-import com.google.common.base.Strings;
import com.google.common.collect.Collections2;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
+import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.TreeMap;
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.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
*/
final List<Module> sortedModules = new ArrayList<>(filteredModulesBuilder.build());
sortedModules.sort(NAME_REVISION_COMPARATOR);
- this.filteredModules = ImmutableSet.copyOf(sortedModules);
+ filteredModules = ImmutableSet.copyOf(sortedModules);
final SetMultimap<XMLNamespace, Module> nsMap = Multimaps.newSetMultimap(new TreeMap<>(),
AbstractSchemaContext::createModuleSet);
for (ModuleImport moduleImport : module.getImports()) {
Optional<Revision> revisionDate = moduleImport.getRevision();
if (revisionDate.isEmpty()) {
- revisionDate = nameToModulesAll.get(moduleImport.getModuleName()).first().getRevision();
+ revisionDate = nameToModulesAll.get(moduleImport.getModuleName().getLocalName()).first()
+ .getRevision();
}
ModuleId key = new ModuleId(moduleImport.getModuleName(), revisionDate);
}
public static final class ModuleId {
- private final String name;
+ private final Unqualified name;
private final Revision rev;
public ModuleId(final String name, final Optional<Revision> rev) {
- checkArgument(!Strings.isNullOrEmpty(name), "No module dependency name given. Nothing to do.");
- this.name = name;
- checkArgument(rev.isPresent(), "No revision date given. Nothing to do.");
- this.rev = rev.get();
+ this(Unqualified.of(name), rev);
}
- public String getName() {
+ public ModuleId(final Unqualified name, final Optional<Revision> rev) {
+ this.name = requireNonNull(name);
+ this.rev = rev.orElseThrow(() -> new IllegalArgumentException("No revision date given. Nothing to do."));
+ }
+
+ public Unqualified getName() {
return name;
}
@Override
public boolean equals(final Object obj) {
- if (this == obj) {
- return true;
- }
- if (!(obj instanceof ModuleId)) {
- return false;
- }
-
- ModuleId moduleId = (ModuleId) obj;
- if (name != null ? !name.equals(moduleId.name) : moduleId.name != null) {
- return false;
- }
- if (rev != null ? !rev.equals(moduleId.rev) : moduleId.rev != null) {
- return false;
- }
-
- return true;
+ return this == obj || obj instanceof ModuleId other && name.equals(other.name)
+ && Objects.equals(rev, other.rev);
}
@Override
import java.util.HashSet;
import java.util.Set;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleLike;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.Submodule;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
/**
}
private static SourceIdentifier moduleToIdentifier(final ModuleLike module) {
- return RevisionSourceIdentifier.create(module.getName(), module.getRevision());
+ return new SourceIdentifier(Unqualified.of(module.getName()), module.getRevision().orElse(null));
}
}
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.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
for (final Module module : imports) {
mockedImports.add(new ModuleImport() {
@Override
- public String getModuleName() {
- return module.getName();
+ public Unqualified getModuleName() {
+ return Unqualified.of(module.getName());
}
@Override
import static org.junit.Assert.assertTrue;
import com.google.common.collect.ImmutableSet;
-import java.util.Optional;
import java.util.Set;
import org.junit.Test;
-import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.spi.SimpleSchemaContext;
import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
public class YT691Test {
@Test
public void testGetAllModuleIdentifiers() {
- final Optional<Revision> revision = Revision.ofNullable("2016-01-01");
- final SourceIdentifier foo = RevisionSourceIdentifier.create("foo", revision);
- final SourceIdentifier sub1Foo = RevisionSourceIdentifier.create("sub1-foo", revision);
- final SourceIdentifier sub2Foo = RevisionSourceIdentifier.create("sub2-foo", revision);
- final SourceIdentifier bar = RevisionSourceIdentifier.create("bar", revision);
- final SourceIdentifier sub1Bar = RevisionSourceIdentifier.create("sub1-bar", revision);
- final SourceIdentifier baz = RevisionSourceIdentifier.create("baz", revision);
+ final SourceIdentifier foo = new SourceIdentifier("foo", "2016-01-01");
+ final SourceIdentifier sub1Foo = new SourceIdentifier("sub1-foo", "2016-01-01");
+ final SourceIdentifier sub2Foo = new SourceIdentifier("sub2-foo", "2016-01-01");
+ final SourceIdentifier bar = new SourceIdentifier("bar", "2016-01-01");
+ final SourceIdentifier sub1Bar = new SourceIdentifier("sub1-bar", "2016-01-01");
+ final SourceIdentifier baz = new SourceIdentifier("baz", "2016-01-01");
final Set<SourceIdentifier> testSet = ImmutableSet.of(foo, sub1Foo, sub2Foo, bar, sub1Bar, baz);
final EffectiveModelContext context = YangParserTestUtils.parseYangResourceDirectory("/yt691");
final Set<SourceIdentifier> allModuleIdentifiers = SchemaContextUtil.getConstituentModuleIdentifiers(context);
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.rfc8040.model.api.YangDataConstants;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.stmt.ContainerStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement;
* An {@link InferenceAction} tasked with identifying when we are dealing with {@link YangDataConstants#RFC8040_SOURCE}.
*/
final class OperationsValidateModuleAction implements InferenceAction {
- private static final String IETF_RESTCONF = YangDataConstants.RFC8040_SOURCE.getName();
+ private static final Unqualified IETF_RESTCONF = YangDataConstants.RFC8040_SOURCE.name();
private final Prerequisite<? extends Mutable<?, ?, ?>> prereq;
static void applyTo(@NonNull final Mutable<?, ?, ?> module) {
// Quick checks we can
- if (module.producesDeclared(ModuleStatement.class) && IETF_RESTCONF.equals(module.rawArgument())) {
+ if (module.producesDeclared(ModuleStatement.class) && IETF_RESTCONF.equals(module.argument())) {
// This is 'yang-api' definition within a 'ietf-restconf' module, but we are not certain about revisions
// and its structure. Next up we require the module to be fully declared, hence an inference action is
// needed to continue this process.
import java.util.Optional;
import java.util.Set;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
import org.opendaylight.yangtools.yang.model.api.stmt.ImportEffectiveStatement;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
// in case of submodule, remember belongs to
if (dep instanceof YangModelDependencyInfo.SubmoduleDependencyInfo) {
- final String parent = ((YangModelDependencyInfo.SubmoduleDependencyInfo) dep).getParentModule();
+ final var parent = ((YangModelDependencyInfo.SubmoduleDependencyInfo) dep).getParentModule();
submodules.put(id, new BelongsToDependency(parent));
}
}
private static class BelongsToDependency implements ModuleImport {
- private final String parent;
+ private final Unqualified parent;
- BelongsToDependency(final String parent) {
+ BelongsToDependency(final Unqualified parent) {
this.parent = parent;
}
@Override
- public String getModuleName() {
+ public Unqualified getModuleName() {
return parent;
}
import java.util.Collection;
import java.util.Map;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.parser.api.YangParserConfiguration;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YangModelDependencyInfo;
super(depInfo);
}
- protected static SourceIdentifier findWildcard(final Iterable<SourceIdentifier> haystack, final String needle) {
+ protected static SourceIdentifier findWildcard(final Iterable<SourceIdentifier> haystack,
+ final Unqualified needle) {
for (final SourceIdentifier r : haystack) {
- if (needle.equals(r.getName())) {
+ if (needle.equals(r.name())) {
return r;
}
}
@Override
protected boolean isKnown(final Collection<SourceIdentifier> haystack, final ModuleImport mi) {
- final SourceIdentifier msi = RevisionSourceIdentifier.create(mi.getModuleName(), mi.getRevision());
+ final SourceIdentifier msi = new SourceIdentifier(mi.getModuleName(), mi.getRevision().orElse(null));
// Quick lookup
if (haystack.contains(msi)) {
final SourceIdentifier expectedSId = srcIt.next();
if (!expectedSId.equals(realSId)) {
LOG.warn("Source identifier mismatch for module \"{}\", requested as {} but actually is {}. "
- + "Using actual id", expectedSId.getName(), expectedSId, realSId);
+ + "Using actual id", expectedSId.name().getLocalName(), expectedSId, realSId);
}
}
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.repo.api.EffectiveModelContextFactory;
import org.opendaylight.yangtools.yang.model.repo.api.MissingSchemaSourceException;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaContextFactoryConfiguration;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaRepository;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaResolutionException;
final SourceIdentifier parsedId = ast.getIdentifier();
final YangTextSchemaSource text;
if (!parsedId.equals(providedId)) {
- if (!parsedId.getName().equals(providedId.getName())) {
+ if (!parsedId.name().equals(providedId.name())) {
LOG.info("Provided module name {} does not match actual text {}, corrected",
providedId.toYangFilename(), parsedId.toYangFilename());
} else {
- final Optional<Revision> sourceRev = providedId.getRevision();
- final Optional<Revision> astRev = parsedId.getRevision();
- if (sourceRev.isPresent()) {
- if (!sourceRev.equals(astRev)) {
+ final Revision sourceRev = providedId.revision();
+ if (sourceRev != null) {
+ if (!sourceRev.equals(parsedId.revision())) {
LOG.info("Provided module revision {} does not match actual text {}, corrected",
providedId.toYangFilename(), parsedId.toYangFilename());
}
return YangTextSchemaSource.identifierFromFilename(fileName);
} catch (final IllegalArgumentException e) {
LOG.warn("Invalid file name format in '{}'", fileName, e);
- return RevisionSourceIdentifier.create(fileName);
+ return new SourceIdentifier(fileName);
}
}
* 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.parser.repo;
import static org.junit.Assert.assertEquals;
import java.util.HashMap;
import java.util.Map;
import org.junit.Test;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.parser.rfc7950.repo.YangModelDependencyInfo;
final String yangFileName) throws Exception {
final var info = ModuleDependencyInfo.forYangText(YangTextSchemaSource.forResource(DependencyResolverTest.class,
yangFileName));
- map.put(RevisionSourceIdentifier.create(info.getName(), info.getRevision()), info);
+ map.put(new SourceIdentifier(info.getName(), info.getFormattedRevision()), info);
}
}
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.repo.api.MissingSchemaSourceException;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaContextFactoryConfiguration;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
public void setUp() {
final YangTextSchemaSource source1 = YangTextSchemaSource.forResource("/ietf/ietf-inet-types@2010-09-24.yang");
final YangTextSchemaSource source2 = YangTextSchemaSource.forResource("/ietf/iana-timezones@2012-07-09.yang");
- s1 = RevisionSourceIdentifier.create("ietf-inet-types", Revision.of("2010-09-24"));
- s2 = RevisionSourceIdentifier.create("iana-timezones", Revision.of("2012-07-09"));
+ s1 = new SourceIdentifier("ietf-inet-types", "2010-09-24");
+ s2 = new SourceIdentifier("iana-timezones", "2012-07-09");
final TextToIRTransformer transformer = TextToIRTransformer.create(repository, repository);
repository.registerSchemaSourceListener(transformer);
provider.register(repository);
// Register the same provider under source id without revision
- final SourceIdentifier sIdWithoutRevision = RevisionSourceIdentifier.create(provider.getId().getName());
+ final SourceIdentifier sIdWithoutRevision = new SourceIdentifier(provider.getId().name());
repository.registerSchemaSource(provider, PotentialSchemaSource.create(
sIdWithoutRevision, IRSchemaSource.class, PotentialSchemaSource.Costs.IMMEDIATE.getValue()));
@Test
public void testTransientFailureWhilreRetrievingSchemaSource() throws Exception {
- final RevisionSourceIdentifier s3 =
- RevisionSourceIdentifier.create("network-topology", Revision.of("2013-10-21"));
+ final SourceIdentifier s3 = new SourceIdentifier("network-topology", "2013-10-21");
repository.registerSchemaSource(new TransientFailureProvider(
YangTextSchemaSource.forResource("/ietf/network-topology@2013-10-21.yang")),
import static org.junit.Assert.assertEquals;
import org.junit.Test;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaResolutionException;
+import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
public class YT1428Test extends AbstractSchemaRepositoryTest {
@Test
public void testDeviateSourceReported() {
final var cause = assertExecutionException(null, "/yt1428/orig.yang", "/yt1428/deviate.yang").getCause();
assertThat(cause, instanceOf(SchemaResolutionException.class));
- assertEquals(RevisionSourceIdentifier.create("deviate"), ((SchemaResolutionException) cause).getFailedSource());
+ assertEquals(new SourceIdentifier("deviate"), ((SchemaResolutionException) cause).getFailedSource());
}
}
package org.opendaylight.yangtools.yang.parser.repo;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
import com.google.common.util.concurrent.ListenableFuture;
import java.io.IOException;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import org.junit.Test;
-import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
+import org.opendaylight.yangtools.yang.model.repo.api.MissingSchemaSourceException;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceException;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
assertEquals(3, yangTextSchemaContextResolver.getAvailableSources().size());
- final SourceIdentifier fooModuleId = RevisionSourceIdentifier.create("foo", Revision.of("2016-09-26"));
+ final SourceIdentifier fooModuleId = new SourceIdentifier("foo", "2016-09-26");
final ListenableFuture<YangTextSchemaSource> foo = yangTextSchemaContextResolver.getSource(fooModuleId);
assertTrue(foo.isDone());
assertEquals(fooModuleId, foo.get().getIdentifier());
- final SourceIdentifier barModuleId = RevisionSourceIdentifier.create("bar", Revision.of("2016-09-26"));
+ final SourceIdentifier barModuleId = new SourceIdentifier("bar", "2016-09-26");
final ListenableFuture<YangTextSchemaSource> bar = yangTextSchemaContextResolver.getSource(barModuleId);
assertTrue(bar.isDone());
assertEquals(barModuleId, bar.get().getIdentifier());
- final SourceIdentifier bazModuleId = RevisionSourceIdentifier.create("baz", Revision.of("2016-09-26"));
+ final SourceIdentifier bazModuleId = new SourceIdentifier("baz", "2016-09-26");
final ListenableFuture<YangTextSchemaSource> baz =
yangTextSchemaContextResolver.getSource(bazModuleId);
assertTrue(baz.isDone());
assertEquals(bazModuleId, baz.get().getIdentifier());
- final SourceIdentifier foobarModuleId = RevisionSourceIdentifier.create("foobar", Revision.of("2016-09-26"));
+ final SourceIdentifier foobarModuleId = new SourceIdentifier("foobar", "2016-09-26");
final ListenableFuture<YangTextSchemaSource> foobar = yangTextSchemaContextResolver.getSource(foobarModuleId);
assertTrue(foobar.isDone());
- try {
- foobar.get();
- fail("A MissingSchemaSourceException should have been thrown.");
- } catch (ExecutionException e) {
- assertEquals("URL for RevisionSourceIdentifier [name=foobar@2016-09-26] not registered",
- e.getCause().getMessage());
- }
+
+ final Throwable cause = assertThrows(ExecutionException.class, foobar::get).getCause();
+ assertThat(cause, instanceOf(MissingSchemaSourceException.class));
+ assertEquals("URL for SourceIdentifier [foobar@2016-09-26] not registered", cause.getMessage());
Optional<? extends SchemaContext> schemaContextOptional =
yangTextSchemaContextResolver.getEffectiveModelContext();
assertTrue(schemaContextOptional.isPresent());
- SchemaContext schemaContext = schemaContextOptional.get();
+ SchemaContext schemaContext = schemaContextOptional.orElseThrow();
assertEquals(3, schemaContext.getModules().size());
registration1.close();
schemaContextOptional = yangTextSchemaContextResolver.getEffectiveModelContext();
assertTrue(schemaContextOptional.isPresent());
- schemaContext = schemaContextOptional.get();
+ schemaContext = schemaContextOptional.orElseThrow();
assertEquals(0, schemaContext.getModules().size());
}
}
package org.opendaylight.yangtools.yang.parser.stmt.reactor;
import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.base.Verify.verify;
import static com.google.common.base.Verify.verifyNotNull;
import static java.util.Objects.requireNonNull;
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.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.parser.spi.meta.DerivedNamespaceBehaviour;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase;
private static SourceIdentifier createSourceIdentifier(final StmtContext<?, ?, ?> root) {
final QNameModule qNameModule = root.getFromNamespace(ModuleCtxToModuleQName.class, root);
- final String arg = root.getRawArgument();
+ final Object arg = root.getArgument();
+ verify(arg instanceof Unqualified, "Unexpected argument %s", arg);
+
if (qNameModule != null) {
// creates SourceIdentifier for a module
- return RevisionSourceIdentifier.create(arg, qNameModule.getRevision());
+ return new SourceIdentifier((Unqualified) arg, qNameModule.getRevision().orElse(null));
}
// creates SourceIdentifier for a submodule
- return RevisionSourceIdentifier.create(arg, StmtContextUtils.getLatestRevision(root.declaredSubstatements()));
+ return new SourceIdentifier((Unqualified) arg,
+ StmtContextUtils.getLatestRevision(root.declaredSubstatements()).orElse(null));
}
@SuppressWarnings("checkstyle:illegalCatch")
checkState(currentPhase == ModelProcessingPhase.SOURCE_PRE_LINKAGE,
"Required library sources can be collected only in ModelProcessingPhase.SOURCE_PRE_LINKAGE phase,"
+ " but current phase was %s", currentPhase);
- final TreeBasedTable<String, Optional<Revision>, SourceSpecificContext> libSourcesTable = TreeBasedTable.create(
- String::compareTo, Revision::compare);
+ final TreeBasedTable<Unqualified, Optional<Revision>, SourceSpecificContext> libSourcesTable =
+ TreeBasedTable.create(Unqualified::compareTo, Revision::compare);
for (final SourceSpecificContext libSource : libSources) {
final SourceIdentifier libSourceIdentifier = requireNonNull(libSource.getRootIdentifier());
- libSourcesTable.put(libSourceIdentifier.getName(), libSourceIdentifier.getRevision(), libSource);
+ libSourcesTable.put(libSourceIdentifier.name(),
+ Optional.ofNullable(libSourceIdentifier.revision()), libSource);
}
final Set<SourceSpecificContext> requiredLibs = new HashSet<>();
}
private void collectRequiredSourcesFromLib(
- final TreeBasedTable<String, Optional<Revision>, SourceSpecificContext> libSourcesTable,
+ final TreeBasedTable<Unqualified, Optional<Revision>, SourceSpecificContext> libSourcesTable,
final Set<SourceSpecificContext> requiredLibs, final SourceSpecificContext source) {
for (final SourceIdentifier requiredSource : source.getRequiredSources()) {
final SourceSpecificContext libSource = getRequiredLibSource(requiredSource, libSourcesTable);
}
private static SourceSpecificContext getRequiredLibSource(final SourceIdentifier requiredSource,
- final TreeBasedTable<String, Optional<Revision>, SourceSpecificContext> libSourcesTable) {
- return requiredSource.getRevision().isPresent()
- ? libSourcesTable.get(requiredSource.getName(), requiredSource.getRevision())
- : getLatestRevision(libSourcesTable.row(requiredSource.getName()));
+ final TreeBasedTable<Unqualified, Optional<Revision>, SourceSpecificContext> libSourcesTable) {
+ final var revision = requiredSource.revision();
+ return revision != null ? libSourcesTable.get(requiredSource.name(), Optional.of(revision))
+ : getLatestRevision(libSourcesTable.row(requiredSource.name()));
}
- private static SourceSpecificContext getLatestRevision(final SortedMap<Optional<Revision>,
- SourceSpecificContext> sourceMap) {
+ private static SourceSpecificContext getLatestRevision(
+ final SortedMap<Optional<Revision>, SourceSpecificContext> sourceMap) {
return sourceMap != null && !sourceMap.isEmpty() ? sourceMap.get(sourceMap.lastKey()) : null;
}
import com.google.common.util.concurrent.Futures;
import java.io.IOException;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.common.Revision;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaRepository;
+import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceRegistry;
import org.opendaylight.yangtools.yang.model.repo.spi.SchemaSourceTransformer;
final IRStatement rootStatement = AntlrSupport.createStatement(YangStatementStreamSource.parseYangSource(text));
final String name = YangModelDependencyInfo.safeStringArgument(text.getIdentifier(), rootStatement, "name");
final String latestRevision = YangModelDependencyInfo.getLatestRevision(rootStatement, text.getIdentifier());
- final RevisionSourceIdentifier sourceId = latestRevision == null ? RevisionSourceIdentifier.create(name)
- : RevisionSourceIdentifier.create(name, Revision.of(latestRevision));
+ final SourceIdentifier sourceId = new SourceIdentifier(name, latestRevision);
return new IRSchemaSource(sourceId, rootStatement, text.getSymbolicName().orElse(null));
}
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.stmt.ImportEffectiveStatement;
if (isBuiltin(substatement, IMPORT)) {
final String importedModuleName = safeStringArgument(source, substatement, "imported module name");
final String revisionDateStr = getRevisionDateString(substatement, source);
- final Revision revisionDate = Revision.ofNullable(revisionDateStr).orElse(null);
- result.add(new ModuleImportImpl(importedModuleName, revisionDate));
+ result.add(new ModuleImportImpl(UnresolvedQName.Unqualified.of(importedModuleName),
+ revisionDateStr != null ? Revision.of(revisionDateStr) : null));
}
}
return ImmutableSet.copyOf(result);
for (final IRStatement substatement : module.statements()) {
if (isBuiltin(substatement, INCLUDE)) {
final String revisionDateStr = getRevisionDateString(substatement, source);
- final String IncludeModuleName = safeStringArgument(source, substatement, "included submodule name");
- final Revision revisionDate = Revision.ofNullable(revisionDateStr).orElse(null);
- result.add(new ModuleImportImpl(IncludeModuleName, revisionDate));
+ final String includeModuleName = safeStringArgument(source, substatement, "included submodule name");
+ result.add(new ModuleImportImpl(UnresolvedQName.Unqualified.of(includeModuleName),
+ revisionDateStr == null ? null : Revision.of(revisionDateStr)));
}
}
return ImmutableSet.copyOf(result);
private static @NonNull YangModelDependencyInfo parseSubmoduleContext(final IRStatement submodule,
final SourceIdentifier source) {
final String name = safeStringArgument(source, submodule, "submodule name");
- final String belongsTo = parseBelongsTo(submodule, source);
+ final UnresolvedQName.Unqualified belongsTo = UnresolvedQName.Unqualified.of(parseBelongsTo(submodule, source));
final String latestRevision = getLatestRevision(submodule, source);
final ImmutableSet<ModuleImport> imports = parseImports(submodule, source);
}
private static StatementSourceReference getReference(final SourceIdentifier source, final IRStatement stmt) {
- return ExplicitStatement.atPosition(source.getName(), stmt.startLine(), stmt.startColumn() + 1);
+ return ExplicitStatement.atPosition(source.name().getLocalName(), stmt.startLine(), stmt.startColumn() + 1);
}
/**
* Dependency information for submodule, also provides name for parent module.
*/
public static final class SubmoduleDependencyInfo extends YangModelDependencyInfo {
- private final String belongsTo;
+ private final UnresolvedQName.Unqualified belongsTo;
- private SubmoduleDependencyInfo(final String name, final String latestRevision, final String belongsTo,
- final ImmutableSet<ModuleImport> imports, final ImmutableSet<ModuleImport> includes) {
+ private SubmoduleDependencyInfo(final String name, final String latestRevision,
+ final UnresolvedQName.Unqualified belongsTo, final ImmutableSet<ModuleImport> imports,
+ final ImmutableSet<ModuleImport> includes) {
super(name, latestRevision, imports, includes);
this.belongsTo = belongsTo;
}
*
* @return The module this info belongs to
*/
- public String getParentModule() {
+ public UnresolvedQName.Unqualified getParentModule() {
return belongsTo;
}
*/
// FIXME: this is a rather nasty misuse of APIs :(
private static final class ModuleImportImpl implements ModuleImport {
- private final @NonNull String moduleName;
+ private final UnresolvedQName.@NonNull Unqualified moduleName;
private final Revision revision;
- ModuleImportImpl(final @NonNull String moduleName, final @Nullable Revision revision) {
+ ModuleImportImpl(final UnresolvedQName.@NonNull Unqualified moduleName, final @Nullable Revision revision) {
this.moduleName = requireNonNull(moduleName, "Module name must not be null.");
this.revision = revision;
}
@Override
- public String getModuleName() {
+ public UnresolvedQName.Unqualified getModuleName() {
return moduleName;
}
final Mutable<?, ?, ?> root = rootPrereq.resolve(ctx);
// Version 1 sources must not import-by-revision Version 1.1 modules
- if (importId.getRevision().isPresent() && root.yangVersion() == YangVersion.VERSION_1) {
+ if (importId.revision() != null && root.yangVersion() == YangVersion.VERSION_1) {
final YangVersion importedVersion = importedModuleContext.yangVersion();
if (importedVersion != YangVersion.VERSION_1) {
throw new YangVersionLinkageException(stmt, "Cannot import by revision version %s module %s",
import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
import java.util.Collection;
-import java.util.Optional;
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.model.api.stmt.ImportStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.parser.rfc7950.namespace.ModuleQNameToPrefix;
import org.opendaylight.yangtools.yang.parser.spi.ModuleNamespace;
imported = importAction.requiresCtx(stmt, ModuleNamespace.class,
NamespaceKeyCriterion.latestRevisionModule(moduleName), SOURCE_LINKAGE);
} else {
- imported = importAction.requiresCtx(stmt, ModuleNamespace.class,
- RevisionSourceIdentifier.create(moduleName, Optional.of(revision)), SOURCE_LINKAGE);
+ imported = importAction.requiresCtx(stmt, ModuleNamespace.class, new SourceIdentifier(moduleName, revision),
+ SOURCE_LINKAGE);
}
- final Prerequisite<Mutable<?, ?, ?>> linkageTarget = importAction.mutatesCtx(stmt.getRoot(),
- SOURCE_LINKAGE);
+ final Prerequisite<Mutable<?, ?, ?>> linkageTarget = importAction.mutatesCtx(stmt.getRoot(), SOURCE_LINKAGE);
importAction.apply(new InferenceAction() {
@Override
}
static SourceIdentifier getImportedSourceIdentifier(final StmtContext<Unqualified, ImportStatement, ?> stmt) {
- final StmtContext<Revision, ?, ?> revision = findFirstDeclaredSubstatement(stmt,
- RevisionDateStatement.class);
- return revision == null ? RevisionSourceIdentifier.create(stmt.argument(), Optional.empty())
- : RevisionSourceIdentifier.create(stmt.argument(), revision.argument());
+ final var revision = findFirstDeclaredSubstatement(stmt, RevisionDateStatement.class);
+ return new SourceIdentifier(stmt.getArgument(), revision != null ? revision.getArgument() : null);
}
}
import com.google.common.collect.ImmutableList;
import java.util.Collection;
-import java.util.Optional;
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.stmt.BelongsToEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.BelongsToStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatementDecorators;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
@Override
public void onPreLinkageDeclared(final Mutable<Unqualified, BelongsToStatement, BelongsToEffectiveStatement> ctx) {
- ctx.addRequiredSource(getSourceIdentifier(ctx));
+ ctx.addRequiredSource(new SourceIdentifier(ctx.getArgument()));
}
@Override
final Mutable<Unqualified, BelongsToStatement, BelongsToEffectiveStatement> belongsToCtx) {
ModelActionBuilder belongsToAction = belongsToCtx.newInferenceAction(ModelProcessingPhase.SOURCE_LINKAGE);
- final SourceIdentifier belongsToSourceIdentifier = getSourceIdentifier(belongsToCtx);
+ final SourceIdentifier belongsToSourceIdentifier = new SourceIdentifier(belongsToCtx.getArgument());
final Prerequisite<StmtContext<?, ?, ?>> belongsToPrereq = belongsToAction.requiresCtx(belongsToCtx,
ModuleNamespaceForBelongsTo.class, belongsToCtx.getArgument(), ModelProcessingPhase.SOURCE_LINKAGE);
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return EffectiveStatements.createBelongsTo(stmt.declared(), substatements);
}
-
- private static SourceIdentifier getSourceIdentifier(
- final StmtContext<Unqualified, BelongsToStatement, BelongsToEffectiveStatement> belongsToCtx) {
- return RevisionSourceIdentifier.create(belongsToCtx.getArgument(), Optional.empty());
- }
}
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
-import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.stmt.IncludeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.IncludeStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
+import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatementDecorators;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
import org.opendaylight.yangtools.yang.model.ri.stmt.EffectiveStatements;
@Override
public void onPreLinkageDeclared(final Mutable<Unqualified, IncludeStatement, IncludeEffectiveStatement> stmt) {
- final StmtContext<Revision, ?, ?> revision = findFirstDeclaredSubstatement(stmt,
- RevisionDateStatement.class);
- stmt.addRequiredSource(revision == null ? RevisionSourceIdentifier.create(stmt.argument(), Optional.empty())
- : RevisionSourceIdentifier.create(stmt.argument(), revision.argument()));
+ final var revision = findFirstDeclaredSubstatement(stmt, RevisionDateStatement.class);
+ stmt.addRequiredSource(
+ new SourceIdentifier(stmt.getArgument(), revision != null ? revision.getArgument() : null));
}
@Override
NamespaceKeyCriterion.latestRevisionModule(submoduleName), SOURCE_LINKAGE);
} else {
requiresCtxPrerequisite = includeAction.requiresCtx(stmt, SubmoduleNamespace.class,
- RevisionSourceIdentifier.create(submoduleName, Optional.of(revision.argument())), SOURCE_LINKAGE);
+ new SourceIdentifier(submoduleName, revision.argument()), SOURCE_LINKAGE);
}
includeAction.apply(new InferenceAction() {
"Cannot include a version %s submodule in a version %s module", subVersion, modVersion);
}
- stmt.addToNs(IncludedModuleContext.class, revision != null
- ? RevisionSourceIdentifier.create(submoduleName, revision.argument())
- : RevisionSourceIdentifier.create(submoduleName, Optional.empty()), includedSubModuleContext);
+ stmt.addToNs(IncludedModuleContext.class,
+ new SourceIdentifier(submoduleName, revision != null ? revision.getArgument() : null),
+ includedSubModuleContext);
stmt.addToNs(IncludedSubmoduleNameToModuleCtx.class, stmt.argument(), includedSubModuleContext);
}
import java.util.Collection;
import java.util.List;
import java.util.Map;
-import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.Empty;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.model.api.stmt.ModuleStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatementDecorators;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
stmt.addContext(PreLinkageModuleNamespace.class, moduleName, stmt);
- final Optional<Revision> revisionDate = StmtContextUtils.getLatestRevision(stmt.declaredSubstatements());
- final QNameModule qNameModule = QNameModule.create(moduleNs, revisionDate.orElse(null)).intern();
+ final Revision revisionDate = StmtContextUtils.getLatestRevision(stmt.declaredSubstatements()).orElse(null);
+ final QNameModule qNameModule = QNameModule.create(moduleNs, revisionDate).intern();
stmt.addToNs(ModuleCtxToModuleQName.class, stmt, qNameModule);
- stmt.setRootIdentifier(RevisionSourceIdentifier.create(stmt.getArgument().getLocalName(), revisionDate));
+ stmt.setRootIdentifier(new SourceIdentifier(stmt.getArgument(), revisionDate));
}
@Override
firstAttributeOf(stmt.declaredSubstatements(), NamespaceStatement.class), stmt,
"Namespace of the module [%s] is missing", stmt.argument());
- final Optional<Revision> revisionDate = StmtContextUtils.getLatestRevision(stmt.declaredSubstatements());
- final QNameModule qNameModule = QNameModule.create(moduleNs, revisionDate.orElse(null)).intern();
+ final Revision revisionDate = StmtContextUtils.getLatestRevision(stmt.declaredSubstatements()).orElse(null);
+ final QNameModule qNameModule = QNameModule.create(moduleNs, revisionDate).intern();
final StmtContext<?, ModuleStatement, ModuleEffectiveStatement> possibleDuplicateModule =
stmt.getFromNamespace(NamespaceToModule.class, qNameModule);
if (possibleDuplicateModule != null && possibleDuplicateModule != stmt) {
}
final Unqualified moduleName = stmt.getArgument();
- final SourceIdentifier moduleIdentifier = RevisionSourceIdentifier.create(moduleName, revisionDate);
+ final SourceIdentifier moduleIdentifier = new SourceIdentifier(moduleName, revisionDate);
stmt.addContext(ModuleNamespace.class, moduleIdentifier, stmt);
stmt.addContext(ModuleNamespaceForBelongsTo.class, moduleName, stmt);
import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatementDecorators;
import org.opendaylight.yangtools.yang.model.ri.stmt.DeclaredStatements;
@Override
public void onPreLinkageDeclared(final Mutable<Unqualified, SubmoduleStatement, SubmoduleEffectiveStatement> stmt) {
- stmt.setRootIdentifier(RevisionSourceIdentifier.create(stmt.getRawArgument(),
- StmtContextUtils.getLatestRevision(stmt.declaredSubstatements())));
+ stmt.setRootIdentifier(new SourceIdentifier(stmt.getArgument(),
+ StmtContextUtils.getLatestRevision(stmt.declaredSubstatements()).orElse(null)));
}
@Override
public void onLinkageDeclared(final Mutable<Unqualified, SubmoduleStatement, SubmoduleEffectiveStatement> stmt) {
- final SourceIdentifier submoduleIdentifier = RevisionSourceIdentifier.create(stmt.getRawArgument(),
- StmtContextUtils.getLatestRevision(stmt.declaredSubstatements()));
+ final SourceIdentifier submoduleIdentifier = new SourceIdentifier(stmt.getArgument(),
+ StmtContextUtils.getLatestRevision(stmt.declaredSubstatements()).orElse(null));
final StmtContext<?, SubmoduleStatement, SubmoduleEffectiveStatement>
possibleDuplicateSubmodule = stmt.getFromNamespace(SubmoduleNamespace.class, submoduleIdentifier);
public void test() throws Exception {
final var foo = assertEffectiveModelDir("/bugs/bug8597").findModule("foo").orElseThrow();
for (ModuleImport moduleImport : foo.getImports()) {
- switch (moduleImport.getModuleName()) {
+ switch (moduleImport.getModuleName().getLocalName()) {
case "bar":
assertEquals(Revision.ofNullable("1970-01-01"), moduleImport.getRevision());
assertEquals(Optional.of("bar-ref"), moduleImport.getReference());
import java.util.Collection;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
import org.opendaylight.yangtools.yang.model.api.Submodule;
final Collection<? extends ModuleImport> imports = foo.getImports();
assertEquals(1, imports.size());
final ModuleImport imp1 = imports.iterator().next();
- assertEquals("bar-2", imp1.getModuleName());
+ assertEquals(Unqualified.of("bar-2"), imp1.getModuleName());
assertEquals("bar", imp1.getPrefix());
assertEquals(Revision.ofNullable("2000-01-02"), imp1.getRevision());
assertEquals(1, subImports.size());
final ModuleImport subImp1 = subImports.iterator().next();
- assertEquals("bar-1", subImp1.getModuleName());
+ assertEquals(Unqualified.of("bar-1"), subImp1.getModuleName());
assertEquals("bar", subImp1.getPrefix());
assertEquals(Revision.ofNullable("2000-01-01"), subImp1.getRevision());
}
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.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.common.YangVersion;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
assertEquals(1, imports.size());
final ModuleImport importStmt = imports.iterator().next();
assertNotNull(importStmt);
- assertEquals("imported", importStmt.getModuleName());
+ assertEquals(Unqualified.of("imported"), importStmt.getModuleName());
assertEquals(Optional.of(REVISION), importStmt.getRevision());
assertEquals("imp-pref", importStmt.getPrefix());
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.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
Collection<? extends ModuleImport> imports = interfacesModule20121115.getImports();
assertEquals(1, imports.size());
ModuleImport interfacesImport = imports.iterator().next();
- assertEquals("ietf-yang-types", interfacesImport.getModuleName());
+ assertEquals(Unqualified.of("ietf-yang-types"), interfacesImport.getModuleName());
assertEquals(Optional.of(rev20100924), interfacesImport.getRevision());
}
Collection<? extends ModuleImport> imports = interfacesModule20121115.getImports();
assertEquals(1, imports.size());
ModuleImport interfacesImport = imports.iterator().next();
- assertEquals("ietf-yang-types", interfacesImport.getModuleName());
+ assertEquals(Unqualified.of("ietf-yang-types"), interfacesImport.getModuleName());
assertEquals(Optional.of(rev20100924), interfacesImport.getRevision());
}
Collection<? extends ModuleImport> imports = monitoringModule19700101.getImports();
assertEquals(1, imports.size());
ModuleImport monitoringImport = imports.iterator().next();
- assertEquals("ietf-yang-types", monitoringImport.getModuleName());
+ assertEquals(Unqualified.of("ietf-yang-types"), monitoringImport.getModuleName());
assertEquals(Optional.of(rev20130715), monitoringImport.getRevision());
}
}
}
- return context.findModule(requestedModuleImport.getModuleName(), requestedModuleImport.getRevision())
+ return context.findModule(requestedModuleImport.getModuleName().getLocalName(),
+ requestedModuleImport.getRevision())
.orElse(null);
}
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Revision;
+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.AugmentationSchemaNode;
assertEquals(2, imports.size());
final ModuleImport import2 = TestUtils.findImport(imports, "br");
- assertEquals("bar", import2.getModuleName());
+ assertEquals(Unqualified.of("bar"), import2.getModuleName());
assertEquals(Revision.ofNullable("2013-07-03"), import2.getRevision());
final ModuleImport import3 = TestUtils.findImport(imports, "bz");
- assertEquals("baz", import3.getModuleName());
+ assertEquals(Unqualified.of("baz"), import3.getModuleName());
assertEquals(Revision.ofNullable("2013-02-27"), import3.getRevision());
assertEquals(Optional.of("opendaylight"), FOO.getOrganization());
import java.util.Collection;
import java.util.Iterator;
import org.junit.Test;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
Iterator<? extends ModuleImport> importsIterator = imports.iterator();
ModuleImport moduleImport = importsIterator.next();
- assertThat(moduleImport.getModuleName(), anyOf(is("ietf-yang-types"), is("ietf-inet-types")));
+ final var nameMatch = anyOf(is(Unqualified.of("ietf-yang-types")),
+ is(Unqualified.of("ietf-inet-types")));
+
+ assertThat(moduleImport.getModuleName(), nameMatch);
assertThat(moduleImport.getPrefix(), anyOf(is("yang"), is("inet")));
moduleImport = importsIterator.next();
- assertThat(moduleImport.getModuleName(), anyOf(is("ietf-yang-types"), is("ietf-inet-types")));
+ assertThat(moduleImport.getModuleName(), nameMatch);
assertThat(moduleImport.getPrefix(), anyOf(is("yang"), is("inet")));
}
}
@Override
public boolean match(final SourceIdentifier key) {
- return moduleName.getLocalName().equals(key.getName());
+ return moduleName.equals(key.name());
}
@Override
public SourceIdentifier select(final SourceIdentifier first, final SourceIdentifier second) {
- return Revision.compare(first.getRevision(), second.getRevision()) >= 0 ? first : second;
+ return Revision.compare(first.revision(), second.revision()) >= 0 ? first : second;
}
@Override
import org.apache.maven.model.Plugin;
import org.apache.maven.project.MavenProject;
import org.apache.maven.repository.RepositorySystem;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.model.api.ModuleLike;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
static SourceIdentifier moduleToIdentifier(final ModuleLike module) {
- return RevisionSourceIdentifier.create(module.getName(), module.getRevision());
+ return new SourceIdentifier(Unqualified.of(module.getName()), module.getRevision().orElse(null));
}
}
+++ /dev/null
-/*
- * Copyright (c) 2016 Cisco Systems, Inc. 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.model.repo.api;
-
-import com.google.common.annotations.Beta;
-import java.util.Objects;
-import java.util.Optional;
-import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.yang.common.Revision;
-import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
-
-/**
- * YANG Schema revision source identifier.
- *
- * <p>
- * Simple transfer object represents revision identifier of source for YANG schema (module or submodule), which consists
- * of
- * <ul>
- * <li>YANG schema name ({@link #getName()}
- * <li>Module revision (optional) ({link {@link #getRevision()})
- * </ul>
- *
- * <p>
- * Revision source identifier is designated to be carry only necessary information to look-up YANG model source
- * and to be used by various SchemaSourceProviders.
- *
- * <p>
- * <b>Note:</b>On source retrieval layer it is impossible to distinguish between YANG module and/or submodule unless
- * source is present.
- *
- * <p>
- * (For further reference see: http://tools.ietf.org/html/rfc6020#section-5.2
- * and http://tools.ietf.org/html/rfc6022#section-3.1 ).
- */
-@Beta
-public final class RevisionSourceIdentifier extends SourceIdentifier {
- private static final long serialVersionUID = 1L;
-
- /**
- * Creates new YANG Schema revision source identifier for sources without a revision.
- *
- * @param name Name of schema
- */
- RevisionSourceIdentifier(final String name) {
- super(name);
- }
-
- /**
- * Creates new YANG Schema revision source identifier.
- *
- * @param name Name of schema
- * @param revision Revision of source, may be null
- */
- RevisionSourceIdentifier(final String name, final @Nullable Revision revision) {
- super(name, revision);
- }
-
- /**
- * Creates new YANG Schema revision source identifier.
- *
- * @param name Name of schema
- * @param formattedRevision Revision of source, potentially not present
- */
- private RevisionSourceIdentifier(final String name, final Optional<Revision> revision) {
- super(name, revision);
- }
-
- /**
- * Creates new YANG Schema revision source identifier.
- *
- * @param moduleName Name of schema
- * @param revision Revision of source in format YYYY-mm-dd. If not present, default value will be used.
- * @return A RevisionSourceIdentifier
- */
- public static @NonNull RevisionSourceIdentifier create(final String moduleName, final Optional<Revision> revision) {
- return new RevisionSourceIdentifier(moduleName, revision);
- }
-
- public static @NonNull RevisionSourceIdentifier create(final Unqualified moduleName,
- final Optional<Revision> revision) {
- return create(moduleName.getLocalName(), revision);
- }
-
- /**
- * Creates new YANG Schema revision source identifier.
- *
- * @param moduleName Name of schema
- * @param revision Revision of source, may be null
- * @return A RevisionSourceIdentifier
- */
- public static @NonNull RevisionSourceIdentifier create(final String moduleName, final @Nullable Revision revision) {
- return new RevisionSourceIdentifier(moduleName, revision);
- }
-
- public static @NonNull RevisionSourceIdentifier create(final Unqualified moduleName,
- final @Nullable Revision revision) {
- return create(moduleName.getLocalName(), revision);
- }
-
- /**
- * Creates new YANG Schema revision source identifier for sources without
- * a revision.
- *
- * @param moduleName Name of schema
- * @return A RevisionSourceIdentifier
- */
- public static @NonNull RevisionSourceIdentifier create(final String moduleName) {
- return new RevisionSourceIdentifier(moduleName);
- }
-
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result + Objects.hashCode(getName());
- result = prime * result + Objects.hashCode(getRevision());
- return result;
- }
-
- @Override
- public boolean equals(final Object obj) {
- if (this == obj) {
- return true;
- }
- if (!(obj instanceof RevisionSourceIdentifier other)) {
- return false;
- }
- return Objects.equals(getName(), other.getName()) && Objects.equals(getRevision(), other.getRevision());
- }
-
- @Override
- public String toString() {
- final StringBuilder sb = new StringBuilder("RevisionSourceIdentifier [name=");
- sb.append(getName());
-
- final Optional<Revision> rev = getRevision();
- if (rev.isPresent()) {
- sb.append('@').append(rev.get());
- }
- return sb.append(']').toString();
- }
-}
import static java.util.Objects.requireNonNull;
-import com.google.common.annotations.Beta;
-import com.google.common.collect.Interner;
-import com.google.common.collect.Interners;
-import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.concepts.Identifier;
-import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.Revision;
+import org.opendaylight.yangtools.yang.common.UnresolvedQName.Unqualified;
import org.opendaylight.yangtools.yang.common.YangConstants;
/**
* For further reference see: <a href="https://tools.ietf.org/html/rfc6020#section-5.2">RFC6020</a>
* and <a href="https://tools.ietf.org/html/rfc6022#section-3.1">RFC6022</a>.
*/
-@Beta
-public abstract class SourceIdentifier implements Identifier, Immutable {
- private static final Interner<SourceIdentifier> INTERNER = Interners.newWeakInterner();
- private static final long serialVersionUID = 2L;
-
- private final @Nullable Revision revision;
- private final @NonNull String name;
+public record SourceIdentifier(@NonNull Unqualified name, @Nullable Revision revision) implements Identifier {
+ private static final long serialVersionUID = 3L;
/**
- * Creates new YANG Schema source identifier for sources without revision.
+ * Creates new YANG Schema source identifier for sources with or without a revision.
*
* @param name Name of schema
+ * @param revision Revision of schema
+ * @throws NullPointerException if {@code name} is null
*/
- SourceIdentifier(final String name) {
- this(name, (Revision) null);
+ public SourceIdentifier {
+ requireNonNull(name);
}
/**
- * Creates new YANG Schema source identifier.
+ * Creates new YANG Schema source identifier for sources without a revision.
*
* @param name Name of schema
- * @param revision Revision of source, may be null
+ * @throws NullPointerException if {@code name} is null
*/
- SourceIdentifier(final String name, final @Nullable Revision revision) {
- this.name = requireNonNull(name);
- this.revision = revision;
+ public SourceIdentifier(final @NonNull Unqualified name) {
+ this(name, null);
}
/**
- * Creates new YANG Schema source identifier.
+ * Creates new YANG Schema source identifier for sources without a revision.
*
* @param name Name of schema
- * @param revision Revision of source, possibly not present
- */
- SourceIdentifier(final String name, final Optional<Revision> revision) {
- this(name, revision.orElse(null));
- }
-
- /**
- * Return an interned reference to an equivalent SourceIdentifier.
- *
- * @return Interned reference, or this object if it was interned.
+ * @throws NullPointerException if {@code name} is null
+ * @throws IllegalArgumentException if {@code name} is not a valid YANG identifier
*/
- public @NonNull SourceIdentifier intern() {
- return INTERNER.intern(this);
+ public SourceIdentifier(final @NonNull String name) {
+ this(Unqualified.of(name));
}
/**
- * Returns model name.
+ * Creates new YANG Schema source identifier for sources with or without a revision.
*
- * @return model name
- */
- public @NonNull String getName() {
- return name;
- }
-
- /**
- * Returns revision of source or null if revision was not supplied.
- *
- * @return revision of source or null if revision was not supplied.
+ * @param name Name of schema
+ * @throws NullPointerException if {@code name} is null
+ * @throws IllegalArgumentException if {@code name} is not a valid YANG identifier
*/
- public Optional<Revision> getRevision() {
- return Optional.ofNullable(revision);
+ public SourceIdentifier(final @NonNull String name, final @Nullable String revision) {
+ this(Unqualified.of(name), revision != null ? Revision.of(revision) : null);
}
/**
* @return Filename for this source identifier.
*/
public @NonNull String toYangFilename() {
- return toYangFileName(name, Optional.ofNullable(revision));
+ return toYangFileName(name.getLocalName(), revision);
+ }
+
+ @Override
+ public String toString() {
+ final var sb = new StringBuilder("SourceIdentifier [").append(name.getLocalName());
+ if (revision != null) {
+ sb.append('@').append(revision);
+ }
+ return sb.append(']').toString();
}
/**
* @param revision optional revision
* @return Filename for this source identifier.
*/
- public static @NonNull String toYangFileName(final String moduleName, final Optional<Revision> revision) {
+ public static @NonNull String toYangFileName(final @NonNull String moduleName, final @Nullable Revision revision) {
final StringBuilder sb = new StringBuilder(moduleName);
- if (revision.isPresent()) {
- sb.append('@').append(revision.orElseThrow());
+ if (revision != null) {
+ sb.append('@').append(revision);
}
return sb.append(YangConstants.RFC6020_YANG_FILE_EXTENSION).toString();
}
import java.nio.file.Files;
import java.nio.file.Path;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.common.Revision;
/**
* YANG text schema source representation. Exposes an RFC6020 or RFC7950 text representation as an {@link InputStream}.
final String baseName = name.substring(0, name.length() - RFC6020_YANG_FILE_EXTENSION.length());
final var parsed = parseFilename(baseName);
- return RevisionSourceIdentifier.create(parsed.getKey(), Revision.ofNullable(parsed.getValue()));
+ return new SourceIdentifier(parsed.getKey(), parsed.getValue());
}
/**
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.Revision;
import org.opendaylight.yangtools.yang.common.YangConstants;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
final Attr dateAttr = revisionStmt.getAttributeNode(REVISION_ARG);
checkArgument(dateAttr != null, "No revision statement argument found in %s", revisionStmt);
- final SourceIdentifier parsedId = RevisionSourceIdentifier.create(nameAttr.getValue(),
- Revision.of(dateAttr.getValue()));
+ final SourceIdentifier parsedId = new SourceIdentifier(nameAttr.getValue(), dateAttr.getValue());
final SourceIdentifier id;
if (!parsedId.equals(identifier)) {
LOG.debug("Changed identifier from {} to {}", identifier, parsedId);
import java.nio.file.Files;
import java.nio.file.Path;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.YangConstants;
import org.opendaylight.yangtools.yang.common.YangNames;
import org.slf4j.Logger;
}
final var parsed = YangNames.parseFilename(baseName);
- return RevisionSourceIdentifier.create(parsed.getKey(), Revision.ofNullable(parsed.getValue()));
+ return new SourceIdentifier(parsed.getKey(), parsed.getValue());
}
@Override
import java.util.regex.Pattern;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.repo.api.MissingSchemaSourceException;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceRepresentation;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
}
static File sourceIdToFile(final SourceIdentifier identifier, final File storageDirectory) {
- final Optional<Revision> rev = identifier.getRevision();
+ final Revision rev = identifier.revision();
final File file;
- if (rev.isEmpty()) {
+ if (rev == null) {
// FIXME: this does not look right
file = findFileWithNewestRev(identifier, storageDirectory);
} else {
return file;
}
- @SuppressFBWarnings(value = "NP_NULL_ON_SOME_PATH_FROM_RETURN_VALUE",
- justification = "listFiles is analyzed to return null")
private static File findFileWithNewestRev(final SourceIdentifier identifier, final File storageDirectory) {
File[] files = storageDirectory.listFiles(new FilenameFilter() {
- final Pattern pat = Pattern.compile(Pattern.quote(identifier.getName())
+ final Pattern pat = Pattern.compile(Pattern.quote(identifier.name().getLocalName())
+ "(\\.yang|@\\d\\d\\d\\d-\\d\\d-\\d\\d.yang)");
@Override
if (matcher.matches()) {
final String moduleName = matcher.group("moduleName");
final String revision = matcher.group("revision");
- return Optional.of(RevisionSourceIdentifier.create(moduleName, Revision.ofNullable(revision)));
+ return Optional.of(new SourceIdentifier(moduleName, revision));
}
return Optional.empty();
}
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import org.junit.Test;
-import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.repo.api.MissingSchemaSourceException;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceRepresentation;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
assertEquals(4, listener.registeredSources.size());
assertThat(Lists.transform(listener.registeredSources, PotentialSchemaSource::getSourceIdentifier),
- both(hasItem(RevisionSourceIdentifier.create("test", Optional.empty())))
- .and(hasItem(RevisionSourceIdentifier.create("test", Revision.of("2012-12-12"))))
- .and(hasItem(RevisionSourceIdentifier.create("test", Revision.of("2013-12-12"))))
- .and(hasItem(RevisionSourceIdentifier.create("module", Revision.of("2010-12-12"))))
+ both(hasItem(new SourceIdentifier("test")))
+ .and(hasItem(new SourceIdentifier("test", "2012-12-12")))
+ .and(hasItem(new SourceIdentifier("test", "2013-12-12")))
+ .and(hasItem(new SourceIdentifier("module", "2010-12-12")))
);
}
sharedSchemaRepository, YangTextSchemaSource.class, storageDir);
sharedSchemaRepository.registerSchemaSourceListener(cache);
- final SourceIdentifier runningId = RevisionSourceIdentifier.create("running", Revision.of("2012-12-12"));
+ final SourceIdentifier runningId = new SourceIdentifier("running", "2012-12-12");
sharedSchemaRepository.registerSchemaSource(sourceIdentifier -> immediateFluentFuture(
new YangTextSchemaSource(runningId) {
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.yangtools.yang.common.Revision;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
import org.opendaylight.yangtools.yang.model.repo.spi.PotentialSchemaSource;
@Before
public void setUp() throws Exception {
- this.storageDir = Files.createTempDir();
- doReturn(this.registration).when(this.registry).registerSchemaSource(any(SchemaSourceProvider.class),
+ storageDir = Files.createTempDir();
+ doReturn(registration).when(registry).registerSchemaSource(any(SchemaSourceProvider.class),
any(PotentialSchemaSource.class));
}
@Test
public void testCacheAndRestore() throws Exception {
final FilesystemSchemaSourceCache<YangTextSchemaSource> cache
- = new FilesystemSchemaSourceCache<>(this.registry, YangTextSchemaSource.class, this.storageDir);
+ = new FilesystemSchemaSourceCache<>(registry, YangTextSchemaSource.class, storageDir);
final String content = "content1";
final YangTextSchemaSource source = new TestingYangSource("test", "2012-12-12", content);
assertThat(Files.asCharSource(storedFiles.get(1), StandardCharsets.UTF_8).read(),
either(containsString(content)).or(containsString(content2)));
- verify(this.registry, times(2)).registerSchemaSource(any(SchemaSourceProvider.class),
+ verify(registry, times(2)).registerSchemaSource(any(SchemaSourceProvider.class),
any(PotentialSchemaSource.class));
// Create new cache from stored sources
- new FilesystemSchemaSourceCache<>(this.registry, YangTextSchemaSource.class, this.storageDir);
+ new FilesystemSchemaSourceCache<>(registry, YangTextSchemaSource.class, storageDir);
- verify(this.registry, times(4)).registerSchemaSource(any(SchemaSourceProvider.class),
+ verify(registry, times(4)).registerSchemaSource(any(SchemaSourceProvider.class),
any(PotentialSchemaSource.class));
final List<File> storedFilesAfterNewCache = getFilesFromCache();
@Test
public void testCacheDuplicate() throws Exception {
final FilesystemSchemaSourceCache<YangTextSchemaSource> cache
- = new FilesystemSchemaSourceCache<>(this.registry, YangTextSchemaSource.class, this.storageDir);
+ = new FilesystemSchemaSourceCache<>(registry, YangTextSchemaSource.class, storageDir);
final String content = "content1";
final YangTextSchemaSource source = new TestingYangSource("test", null, content);
final List<File> storedFiles = getFilesFromCache();
assertEquals(1, storedFiles.size());
- verify(this.registry).registerSchemaSource(any(SchemaSourceProvider.class), any(PotentialSchemaSource.class));
+ verify(registry).registerSchemaSource(any(SchemaSourceProvider.class), any(PotentialSchemaSource.class));
}
@Test
public void testCacheMultipleRevisions() throws Exception {
final FilesystemSchemaSourceCache<YangTextSchemaSource> cache
- = new FilesystemSchemaSourceCache<>(this.registry, YangTextSchemaSource.class, this.storageDir);
+ = new FilesystemSchemaSourceCache<>(registry, YangTextSchemaSource.class, storageDir);
final String content = "content1";
final YangTextSchemaSource source = new TestingYangSource("test", null, content);
assertThat(filesToFilenamesWithoutRevision(storedFiles), both(hasItem("test"))
.and(hasItem("test@2012-12-12")).and(hasItem("test@2013-12-12")));
- verify(this.registry, times(3)).registerSchemaSource(any(SchemaSourceProvider.class),
+ verify(registry, times(3)).registerSchemaSource(any(SchemaSourceProvider.class),
any(PotentialSchemaSource.class));
}
@Test
public void sourceIdToFileEmptyRevWithEmptyDir() {
- final SourceIdentifier sourceIdentifier = RevisionSourceIdentifier.create("test");
- final File sourceIdToFile = FilesystemSchemaSourceCache.sourceIdToFile(sourceIdentifier, this.storageDir);
- final FilesystemSchemaSourceCache<YangTextSchemaSource> cache = new FilesystemSchemaSourceCache<>(this.registry,
+ final SourceIdentifier sourceIdentifier = new SourceIdentifier("test");
+ final File sourceIdToFile = FilesystemSchemaSourceCache.sourceIdToFile(sourceIdentifier, storageDir);
+ final FilesystemSchemaSourceCache<YangTextSchemaSource> cache = new FilesystemSchemaSourceCache<>(registry,
YangTextSchemaSource.class, sourceIdToFile);
assertNotNull(cache);
final List<File> storedFiles = Arrays.asList(sourceIdToFile.listFiles());
@Test
public void sourceIdToFileEmptyRevWithOneItemInDir() {
- final FilesystemSchemaSourceCache<YangTextSchemaSource> cache = new FilesystemSchemaSourceCache<>(this.registry,
- YangTextSchemaSource.class, this.storageDir);
+ final FilesystemSchemaSourceCache<YangTextSchemaSource> cache = new FilesystemSchemaSourceCache<>(registry,
+ YangTextSchemaSource.class, storageDir);
final String content = "content1";
final YangTextSchemaSource source = new TestingYangSource("test", "2013-12-12", content);
cache.offer(source);
- final SourceIdentifier sourceIdentifier = RevisionSourceIdentifier.create("test");
+ final SourceIdentifier sourceIdentifier = new SourceIdentifier("test");
final File sourceIdToFile = FilesystemSchemaSourceCache.sourceIdToFile(sourceIdentifier,
- this.storageDir);
+ storageDir);
assertNotNull(sourceIdToFile);
- final List<File> storedFiles = Arrays.asList(this.storageDir.listFiles());
+ final List<File> storedFiles = Arrays.asList(storageDir.listFiles());
assertEquals(1, storedFiles.size());
}
@Test
public void sourceIdToFileEmptyRevWithMoreItemsInDir() {
- final FilesystemSchemaSourceCache<YangTextSchemaSource> cache = new FilesystemSchemaSourceCache<>(this.registry,
- YangTextSchemaSource.class, this.storageDir);
+ final FilesystemSchemaSourceCache<YangTextSchemaSource> cache = new FilesystemSchemaSourceCache<>(registry,
+ YangTextSchemaSource.class, storageDir);
final String content = "content1";
final YangTextSchemaSource source = new TestingYangSource("test", "2012-12-12", content);
final YangTextSchemaSource source2 = new TestingYangSource("test", "2013-12-12", content);
cache.offer(source);
cache.offer(source2);
- final SourceIdentifier sourceIdentifier = RevisionSourceIdentifier.create("test");
- final File sourceIdToFile = FilesystemSchemaSourceCache.sourceIdToFile(sourceIdentifier, this.storageDir);
+ final SourceIdentifier sourceIdentifier = new SourceIdentifier("test");
+ final File sourceIdToFile = FilesystemSchemaSourceCache.sourceIdToFile(sourceIdentifier, storageDir);
assertNotNull(sourceIdToFile);
- final List<File> storedFiles = Arrays.asList(this.storageDir.listFiles());
+ final List<File> storedFiles = Arrays.asList(storageDir.listFiles());
assertEquals(2, storedFiles.size());
}
@Test
public void test() throws Exception {
- final FilesystemSchemaSourceCache<YangTextSchemaSource> cache = new FilesystemSchemaSourceCache<>(this.registry,
- YangTextSchemaSource.class, this.storageDir);
+ final FilesystemSchemaSourceCache<YangTextSchemaSource> cache = new FilesystemSchemaSourceCache<>(registry,
+ YangTextSchemaSource.class, storageDir);
final String content = "content1";
final YangTextSchemaSource source = new TestingYangSource("test", "2013-12-12", content);
cache.offer(source);
- final SourceIdentifier sourceIdentifier = RevisionSourceIdentifier.create("test", Revision.of("2013-12-12"));
+ final SourceIdentifier sourceIdentifier = new SourceIdentifier("test", "2013-12-12");
final ListenableFuture<? extends YangTextSchemaSource> checked = cache.getSource(sourceIdentifier);
assertNotNull(checked);
final YangTextSchemaSource checkedGet = checked.get();
@Test
public void test1() throws Exception {
- final FilesystemSchemaSourceCache<YangTextSchemaSource> cache = new FilesystemSchemaSourceCache<>(this.registry,
- YangTextSchemaSource.class, this.storageDir);
+ final FilesystemSchemaSourceCache<YangTextSchemaSource> cache = new FilesystemSchemaSourceCache<>(registry,
+ YangTextSchemaSource.class, storageDir);
final String content = "content1";
final YangTextSchemaSource source = new TestingYangSource("test", "2013-12-12", content);
cache.offer(source);
- final SourceIdentifier sourceIdentifier = RevisionSourceIdentifier.create("test1", Revision.of("2012-12-12"));
+ final SourceIdentifier sourceIdentifier = new SourceIdentifier("test1", "2012-12-12");
final ListenableFuture<? extends YangTextSchemaSource> checked = cache.getSource(sourceIdentifier);
assertNotNull(checked);
assertThrows(ExecutionException.class, () -> checked.get());
}
private List<File> getFilesFromCache() {
- return Arrays.asList(this.storageDir.listFiles());
+ return Arrays.asList(storageDir.listFiles());
}
- private class TestingYangSource extends YangTextSchemaSource {
+ private static class TestingYangSource extends YangTextSchemaSource {
private final String content;
TestingYangSource(final String name, final String revision, final String content) {
- super(RevisionSourceIdentifier.create(name, Revision.ofNullable(revision)));
+ super(new SourceIdentifier(name, revision));
this.content = content;
}
@Override
public InputStream openStream() throws IOException {
- return new ByteArrayInputStream(this.content.getBytes(StandardCharsets.UTF_8));
+ return new ByteArrayInputStream(content.getBytes(StandardCharsets.UTF_8));
}
@Override
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.yangtools.yang.common.Revision;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
+import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangSchemaSourceRepresentation;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
final String content = "content";
final YangTextSchemaSource source = new TestingYangSource("test", "2012-12-12", content);
cache.offer(source);
- final var sourceIdentifier = RevisionSourceIdentifier.create("test", Revision.of("2012-12-12"));
+ final var sourceIdentifier = new SourceIdentifier("test", "2012-12-12");
final var checkedSource = cache .getSource(sourceIdentifier);
assertNotNull(checkedSource);
final var yangSchemaSourceRepresentation = checkedSource.get();
@Test
public void inMemorySchemaSourceCacheNullGetSourcestest() throws Exception {
try (var cache = GuavaSchemaSourceCache.createSoftCache(registry, REPRESENTATION)) {
- final var sourceIdentifier = RevisionSourceIdentifier.create("test", Revision.of("2012-12-12"));
+ final var sourceIdentifier = new SourceIdentifier("test", "2012-12-12");
final var checkedSource = cache.getSource(sourceIdentifier);
assertNotNull(checkedSource);
assertThrows(ExecutionException.class, () -> checkedSource.get());
cache1.offer(source);
cache2.offer(source);
- final var sourceIdentifier = RevisionSourceIdentifier.create("test", Revision.of("2012-12-12"));
+ final var sourceIdentifier = new SourceIdentifier("test", "2012-12-12");
final var checkedSource = cache1.getSource(sourceIdentifier);
final var checkedSource2 = cache2.getSource(sourceIdentifier);
assertNotNull(checkedSource);
private final String content;
TestingYangSource(final String name, final String revision, final String content) {
- super(RevisionSourceIdentifier.create(name, Revision.ofNullable(revision)));
+ super(new SourceIdentifier(name, revision));
this.content = content;
}
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceRepresentation;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
}
- @Mock
- public SourceIdentifier sourceIdentifier;
+ public final SourceIdentifier sourceIdentifier = new SourceIdentifier("foo");
@SuppressWarnings("exports")
public PotentialSchemaSource<TestSchemaSourceRepresentation> source;
@SuppressWarnings("exports")
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.yangtools.yang.model.repo.api.EffectiveModelContextFactory;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaContextFactoryConfiguration;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaRepository;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceRepresentation;
@Test
public void schemaSourceTransformerTest() {
- this.schema = new SchemaSourceTransformer<>(
- this.provider, SchemaSourceTransformerTest.SRC_CLASS, this.consumer,
- SchemaSourceTransformerTest.DST_CLASS, this.function);
- assertNotNull(this.schema);
+ schema = new SchemaSourceTransformer<>(
+ provider, SchemaSourceTransformerTest.SRC_CLASS, consumer,
+ SchemaSourceTransformerTest.DST_CLASS, function);
+ assertNotNull(schema);
}
@Test
final Provider p = new Provider();
final Registrator reg = new Registrator(p, SchemaSourceTransformerTest.SRC_CLASS,
PotentialSchemaSource.Costs.IMMEDIATE);
- final SourceIdentifier sourceIdentifier = RevisionSourceIdentifier.create("source");
+ final SourceIdentifier sourceIdentifier = new SourceIdentifier("source");
reg.register(sourceIdentifier);
- this.schema = new SchemaSourceTransformer<>(p,
- SchemaSourceTransformerTest.SRC_CLASS, this.consumer, SchemaSourceTransformerTest.DST_CLASS,
- this.function);
- final SchemaSourceProvider<YinXmlSchemaSource> prov = this.schema;
+ schema = new SchemaSourceTransformer<>(p,
+ SchemaSourceTransformerTest.SRC_CLASS, consumer, SchemaSourceTransformerTest.DST_CLASS,
+ function);
+ final SchemaSourceProvider<YinXmlSchemaSource> prov = schema;
final Future<? extends YinXmlSchemaSource> source = prov.getSource(sourceIdentifier);
assertNotNull(source);
source.cancel(true);
@Test
public void schemaSourceRegAndUnregSchemaSourceTest() {
- final SourceIdentifier sourceIdentifier = RevisionSourceIdentifier.create("source");
+ final SourceIdentifier sourceIdentifier = new SourceIdentifier("source");
final Foo<YangSchemaSourceRepresentation> foo = new Foo<>(sourceIdentifier,
SchemaSourceTransformerTest.SRC_CLASS,
PotentialSchemaSource.Costs.COMPUTATION);
reg.register(sourceIdentifier);
final Consumer c = new Consumer();
- this.schema = new SchemaSourceTransformer<>(p,
- SchemaSourceTransformerTest.SRC_CLASS, c, SchemaSourceTransformerTest.DST_CLASS, this.function);
+ schema = new SchemaSourceTransformer<>(p,
+ SchemaSourceTransformerTest.SRC_CLASS, c, SchemaSourceTransformerTest.DST_CLASS, function);
- final SchemaSourceListener listener = this.schema;
+ final SchemaSourceListener listener = schema;
p.registerSchemaSourceListener(listener);
final PotentialSchemaSource<?>[] potList = { foo.getPotentialSchemSource() };
final Iterable<PotentialSchemaSource<?>> sources = Arrays.asList(potList);
listener.schemaSourceRegistered(sources);
- final ListenableFuture<YinXmlSchemaSource> source = this.schema.getSource(sourceIdentifier);
+ final ListenableFuture<YinXmlSchemaSource> source = schema.getSource(sourceIdentifier);
assertNotNull(source);
listener.schemaSourceUnregistered(foo.getPotentialSchemSource());
- final ListenableFuture<YinXmlSchemaSource> source2 = this.schema.getSource(sourceIdentifier);
+ final ListenableFuture<YinXmlSchemaSource> source2 = schema.getSource(sourceIdentifier);
assertNotNull(source2);
}
- private class Foo<T extends SchemaSourceRepresentation> {
+ private static class Foo<T extends SchemaSourceRepresentation> {
final PotentialSchemaSource<T> src;
}
- private class Registrator extends AbstractSchemaSourceCache<YangSchemaSourceRepresentation> {
+ private static class Registrator extends AbstractSchemaSourceCache<YangSchemaSourceRepresentation> {
Registrator(final SchemaSourceRegistry consumer, final Class<YangSchemaSourceRepresentation> srcClass,
final Costs cost) {
}
- private class Provider extends AbstractSchemaRepository {
+ private static class Provider extends AbstractSchemaRepository {
@Override
public EffectiveModelContextFactory createEffectiveModelContextFactory(
final SchemaContextFactoryConfiguration config) {
}
}
- private class Consumer extends AbstractSchemaRepository {
+ private static class Consumer extends AbstractSchemaRepository {
@Override
public EffectiveModelContextFactory createEffectiveModelContextFactory(
final SchemaContextFactoryConfiguration config) {
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.yangtools.yang.common.Revision;
-import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
+import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.YangSchemaSourceRepresentation;
import org.opendaylight.yangtools.yang.model.repo.api.YangTextSchemaSource;
final String content = "content";
final YangTextSchemaSource source = new TestingYangSource("test", "2012-12-12", content);
cache.offer(source);
- final var sourceIdentifier = RevisionSourceIdentifier.create("test", Revision.of("2012-12-12"));
+ final var sourceIdentifier = new SourceIdentifier("test", "2012-12-12");
final var checkedSource = cache .getSource(sourceIdentifier);
assertNotNull(checkedSource);
final var yangSchemaSourceRepresentation = checkedSource.get();
@Test
public void inMemorySchemaSourceCacheNullGetSourcestest() throws Exception {
try (var cache = new SoftSchemaSourceCache<>(registry, REPRESENTATION)) {
- final var sourceIdentifier = RevisionSourceIdentifier.create("test", Revision.of("2012-12-12"));
+ final var sourceIdentifier = new SourceIdentifier("test", "2012-12-12");
final var checkedSource = cache.getSource(sourceIdentifier);
assertNotNull(checkedSource);
assertThrows(ExecutionException.class, () -> checkedSource.get());
cache1.offer(source);
cache2.offer(source);
- final var sourceIdentifier = RevisionSourceIdentifier.create("test", Revision.of("2012-12-12"));
+ final var sourceIdentifier = new SourceIdentifier("test", "2012-12-12");
final var checkedSource = cache1.getSource(sourceIdentifier);
final var checkedSource2 = cache2.getSource(sourceIdentifier);
assertNotNull(checkedSource);
private final String content;
TestingYangSource(final String name, final String revision, final String content) {
- super(RevisionSourceIdentifier.create(name, Revision.ofNullable(revision)));
+ super(new SourceIdentifier(name, revision));
this.content = content;
}
Code Review / yangtools.git / commitdiff