import com.google.common.collect.ImmutableBiMap;
import com.google.common.collect.ImmutableBiMap.Builder;
import com.google.common.collect.Maps;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.xml.xpath.XPathExpressionException;
import org.opendaylight.yangtools.yang.common.QNameModule;
b.put(module.getPrefix(), module.getQNameModule());
for (ModuleImport i : module.getImports()) {
- final Module mod = ctx.findModuleByName(i.getModuleName(), i.getRevision());
- checkArgument(mod != null, "Unsatisfied import of %s by module %s", i, module);
+ final Optional<Module> mod = ctx.findModule(i.getModuleName(), i.getRevision());
+ checkArgument(mod.isPresent(), "Unsatisfied import of %s by module %s", i, module);
- b.put(i.getPrefix(), mod.getQNameModule());
+ b.put(i.getPrefix(), mod.get().getQNameModule());
}
return Maps.asConverter(b.build());
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
+import java.util.Iterator;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.data.util.codec.QNameCodecUtil;
return parentModule;
}
- final Module module = schemaContext.findModuleByName(prefix, null);
- checkArgument(module != null, "Could not find module %s", prefix);
- return module.getQNameModule();
+ final Iterator<Module> modules = schemaContext.findModules(prefix).iterator();
+ checkArgument(modules.hasNext(), "Could not find module %s", prefix);
+ return modules.next().getQNameModule();
});
}
@Override
public void writeValue(final JsonWriter writer, final QName value) throws IOException {
final String str = QNameCodecUtil.encodeQName(value, uri -> {
- final Module module = schemaContext.findModuleByNamespaceAndRevision(uri.getNamespace(), null);
- checkArgument(module != null, "Cannot find module for %s", uri);
- return module.getName();
+ final Iterator<Module> modules = schemaContext.findModules(uri.getNamespace()).iterator();
+ checkArgument(modules.hasNext(), "Cannot find module for %s", uri);
+ return modules.next().getName();
});
writer.value(str);
}
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.net.URI;
+import java.util.Iterator;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Module;
// Prepend module name if namespaces do not match
final URI ns = qname.getNamespace();
if (!ns.equals(getNamespace())) {
- final Module module = schema.findModuleByNamespaceAndRevision(ns, null);
- checkArgument(module != null, "Could not find module for namespace {}", ns);
+ final Iterator<Module> modules = schema.findModules(ns).iterator();
+ checkArgument(modules.hasNext(), "Could not find module for namespace {}", ns);
- sb.append(module.getName());
+ sb.append(modules.next().getName());
sb.append(':');
}
sb.append(qname.getLocalName());
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.net.URI;
+import java.util.Iterator;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.util.AbstractModuleStringInstanceIdentifierCodec;
@Override
protected Module moduleForPrefix(@Nonnull final String prefix) {
- return context.findModuleByName(prefix, null);
+ final Iterator<Module> modules = context.findModules(prefix).iterator();
+ return modules.hasNext() ? modules.next() : null;
}
@Override
protected String prefixForNamespace(@Nonnull final URI namespace) {
- final Module module = context.findModuleByNamespaceAndRevision(namespace, null);
- return module == null ? null : module.getName();
+ final Iterator<Module> modules = context.findModules(namespace).iterator();
+ return modules.hasNext() ? modules.next().getName() : null;
}
@Nonnull
import java.util.Collections;
import java.util.Deque;
import java.util.HashSet;
+import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
import javax.xml.transform.dom.DOMSource;
moduleNamePart = childName.substring(0, lastIndexOfColon);
nodeNamePart = childName.substring(lastIndexOfColon + 1);
- final Module m = schema.findModuleByName(moduleNamePart, null);
- namespace = m == null ? null : m.getNamespace();
+ final Iterator<Module> m = schema.findModules(moduleNamePart).iterator();
+ namespace = m.hasNext() ? m.next().getNamespace() : null;
} else {
nodeNamePart = childName;
}
for (final URI potentialUri : potentialUris) {
builder.append('\n');
//FIXME how to get information about revision from JSON input? currently first available is used.
- builder.append(schema.findModuleByNamespace(potentialUri).iterator().next().getName());
+ builder.append(schema.findModules(potentialUri).iterator().next().getName());
}
return builder.toString();
}
public static void init() throws XMLStreamException, URISyntaxException, IOException, ParserConfigurationException,
SAXException {
schemaContext = YangParserTestUtils.parseYangResourceDirectory("/yang-modeled-anyxml/yang");
- final Module bazModule = schemaContext.findModuleByName("baz", null);
+ final Module bazModule = schemaContext.findModules("baz").iterator().next();
final ContainerSchemaNode bazCont = (ContainerSchemaNode) bazModule.getDataChildByName(
QName.create(bazModule.getQNameModule(), "baz"));
assertNotNull(bazCont);
import static java.util.Objects.requireNonNull;
import java.net.URI;
+import java.util.Iterator;
import java.util.Map.Entry;
import javax.xml.namespace.NamespaceContext;
import javax.xml.stream.XMLStreamException;
}
final String prefixedNS = ctx.getNamespaceURI(prefix);
- final Module module = schemaContext.findModuleByNamespaceAndRevision(URI.create(prefixedNS), null);
- checkArgument(module != null, "Could not find module for namespace %s", prefixedNS);
- return module.getQNameModule();
+ final Iterator<Module> modules = schemaContext.findModules(URI.create(prefixedNS)).iterator();
+ checkArgument(modules.hasNext(), "Could not find module for namespace %s", prefixedNS);
+ return modules.next().getQNameModule();
});
}
import java.net.URI;
import java.util.ArrayDeque;
import java.util.Deque;
+import java.util.Iterator;
import javax.annotation.Nonnull;
import javax.xml.namespace.NamespaceContext;
import javax.xml.stream.XMLStreamException;
@Override
protected Module moduleForPrefix(@Nonnull final String prefix) {
final String prefixedNS = getNamespaceContext().getNamespaceURI(prefix);
- return context.findModuleByNamespaceAndRevision(URI.create(prefixedNS), null);
+ final Iterator<Module> modules = context.findModules(URI.create(prefixedNS)).iterator();
+ return modules.hasNext() ? modules.next() : null;
}
@Override
protected String prefixForNamespace(@Nonnull final URI namespace) {
- final Module module = context.findModuleByNamespaceAndRevision(namespace, null);
- return module == null ? null : module.getName();
+ final Iterator<Module> modules = context.findModules(namespace).iterator();
+ return modules.hasNext() ? modules.next().getName() : null;
}
@Nonnull
public void testRealSchemaContextFromFoo() throws Exception {
final InputStream resourceAsStream = YangModeledAnyXMLDeserializationTest.class.getResourceAsStream(
"/anyxml-support/xml/foo.xml");
- final Module foo = schemaContext.findModuleByName("foo", null);
+ final Module foo = schemaContext.findModules("foo").iterator().next();
final YangModeledAnyXmlSchemaNode myAnyXmlData = (YangModeledAnyXmlSchemaNode) foo.getDataChildByName(
QName.create(foo.getQNameModule(), "my-anyxml-data"));
public void testSerializationOfBaz() throws Exception {
final InputStream resourceAsStream = XmlToNormalizedNodesTest.class.getResourceAsStream(
"/anyxml-support/serialization/baz.xml");
- final Module bazModule = schemaContext.findModuleByName("baz", null);
+ final Module bazModule = schemaContext.findModules("baz").iterator().next();
final ContainerSchemaNode bazCont = (ContainerSchemaNode) bazModule.getDataChildByName(
QName.create(bazModule.getQNameModule(), "baz"));
assertNotNull(bazCont);
}
public LeafRefPath getAbsoluteLeafRefTargetPath() {
-
if (isReferencing && absoluteLeafRefTargetPath == null) {
if (leafRefTargetPath.isAbsolute()) {
absoluteLeafRefTargetPath = leafRefTargetPath;
} else {
- absoluteLeafRefTargetPath = LeafRefUtils
- .createAbsoluteLeafRefPath(leafRefTargetPath,
- currentNodePath, getLeafRefContextModule());
+ absoluteLeafRefTargetPath = LeafRefUtils.createAbsoluteLeafRefPath(leafRefTargetPath,
+ currentNodePath, getLeafRefContextModule());
}
}
public Module getLeafRefContextModule() {
final Iterator<QName> it = currentNodePath.getPathFromRoot().iterator();
final QNameModule qnameModule = it.hasNext() ? it.next().getModule() : currentNodeQName.getModule();
-
- return schemaContext.findModuleByNamespaceAndRevision(qnameModule.getNamespace(), qnameModule.getRevision());
+ return schemaContext.findModule(qnameModule).orElse(null);
}
public void addReferencedByLeafRefCtx(final QName qname, final LeafRefContext leafRef) {
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
-import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
while (baseLeafRefType.getBaseType() != null) {
baseLeafRefType = baseLeafRefType.getBaseType();
}
- final QNameModule module = baseLeafRefType.getQName().getModule();
- return schemaContext.findModuleByNamespaceAndRevision(module.getNamespace(), module.getRevision());
+ return schemaContext.findModule(baseLeafRefType.getQName().getModule()).orElse(null);
}
private LeafRefContext buildLeafRefContextReferencedByTree(
private URI getNamespaceForImportPrefix(final String prefix) {
final ModuleImport moduleImport = getModuleImport(prefix);
- final Module findedModule = schemaContext.findModuleByName(moduleImport.getModuleName(),
- moduleImport.getRevision());
-
- return findedModule.getNamespace();
+ return schemaContext.findModule(moduleImport.getModuleName(), moduleImport.getRevision()).get().getNamespace();
}
private Optional<QNameModule> getQNameModuleForImportPrefix(final String prefix) {
final String moduleName = moduleImport.getModuleName();
final Date revision = moduleImport.getRevision();
- final Module foundModule = schemaContext.findModuleByName(moduleName, revision);
-
- return Optional.of(foundModule.getQNameModule());
+ return schemaContext.findModule(moduleName, revision).map(Module::getQNameModule);
}
private ModuleImport getModuleImport(final String prefix) {
assertNotNull(schemaContext);
final QNameModule testModuleQName = QNameModule.create(new URI("string-pattern-checking-codec-test"),
- SimpleDateFormatUtil.getRevisionFormat().parse("1970-01-01"));
-
- final Module testModule = schemaContext.findModuleByName("string-pattern-checking-codec-test", null);
- assertNotNull(testModule);
+ SimpleDateFormatUtil.DEFAULT_DATE_REV);
+ final Module testModule = schemaContext.findModules("string-pattern-checking-codec-test").iterator().next();
final ContainerSchemaNode testContainer = (ContainerSchemaNode) testModule.getDataChildByName(
QName.create(testModuleQName, "test-container"));
assertNotNull(testContainer);
}
private QName createQName(final String prefix, final String localName) {
- final Module module = schemaContext.findModuleByNamespaceAndRevision(schemaNode.getQName().getNamespace(),
- schemaNode.getQName().getRevision());
+ final Module module = schemaContext.findModule(schemaNode.getQName().getModule()).get();
if (prefix.isEmpty() || module.getPrefix().equals(prefix)) {
return QName.create(module.getQNameModule(), localName);
}
for (final ModuleImport moduleImport : module.getImports()) {
if (prefix.equals(moduleImport.getPrefix())) {
- final Module importedModule = schemaContext.findModuleByName(moduleImport.getModuleName(),
- moduleImport.getRevision());
+ final Module importedModule = schemaContext.findModule(moduleImport.getModuleName(),
+ moduleImport.getRevision()).get();
return QName.create(importedModule.getQNameModule(),localName);
}
}
private static IdentitySchemaNode getIdentitySchemaNodeFromQName(final QName identityQName,
final SchemaContext schemaContext) {
- final Module module = schemaContext.findModuleByNamespaceAndRevision(identityQName.getNamespace(),
- identityQName.getRevision());
- return findIdentitySchemaNodeInModule(module, identityQName);
+ final Optional<Module> module = schemaContext.findModule(identityQName.getModule());
+ Preconditions.checkArgument(module.isPresent(), "Module for %s not found", identityQName);
+ return findIdentitySchemaNodeInModule(module.get(), identityQName);
}
private static IdentitySchemaNode getIdentitySchemaNodeFromString(final String identity,
final SchemaContext schemaContext, final TypedSchemaNode correspondingSchemaNode) {
final List<String> identityPrefixAndName = COLON_SPLITTER.splitToList(identity);
- final Module module = schemaContext.findModuleByNamespaceAndRevision(
- correspondingSchemaNode.getQName().getNamespace(), correspondingSchemaNode.getQName().getRevision());
+ final Module module = schemaContext.findModule(correspondingSchemaNode.getQName().getModule()).get();
if (identityPrefixAndName.size() == 2) {
// prefix of local module
if (identityPrefixAndName.get(0).equals(module.getPrefix())) {
// prefix of imported module
for (final ModuleImport moduleImport : module.getImports()) {
if (identityPrefixAndName.get(0).equals(moduleImport.getPrefix())) {
- final Module importedModule = schemaContext.findModuleByName(moduleImport.getModuleName(),
- moduleImport.getRevision());
+ final Module importedModule = schemaContext.findModule(moduleImport.getModuleName(),
+ moduleImport.getRevision()).get();
return findIdentitySchemaNodeInModule(importedModule, QName.create(
importedModule.getQNameModule(), identityPrefixAndName.get(1)));
}
import static java.util.Objects.requireNonNull;
import java.net.URI;
+import java.util.Iterator;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.data.api.codec.IdentityrefCodec;
@Override
protected String prefixForNamespace(@Nonnull final URI namespace) {
- final Module module = context.findModuleByNamespaceAndRevision(namespace, null);
- return module == null ? null : module.getName();
+ final Iterator<Module> modules = context.findModules(namespace).iterator();
+ return modules.hasNext() ? modules.next().getName() : null;
}
}
package org.opendaylight.yangtools.yang.model.api;
import java.util.Date;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
/**
* keyword
*/
// FIXME: BUG-4688: should return Optional<Revision>
- // FIXME: this should not be here
- Date getRevision();
+ Optional<Date> getRevision();
+ static int compareRevisions(final Optional<Date> first, final Optional<Date> second) {
+ if (!first.isPresent()) {
+ return second.isPresent() ? -1 : 0;
+ }
+ return second.isPresent() ? first.get().compareTo(second.get()) : 1;
+ }
}
import java.util.Date;
import java.util.Optional;
import java.util.Set;
+import javax.annotation.Nullable;
import javax.annotation.concurrent.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.QNameModule;
/**
* The interface represents static view of compiled yang files,
Set<ExtensionDefinition> getExtensions();
/**
- * Returns module instance (from the context) with concrete name and
- * revision date.
+ * Returns module instance (from the context) with concrete name and revision date.
*
* @param name
* string with the module name
* @param revision
- * date of the module revision
- * @return module instance which has name and revision (if specified) the
- * same as are the values specified in parameters <code>name</code>
- * and <code>revision</code>. In other cases the <code>null</code>
- * value is returned.
- *
+ * date of the module revision, may be null
+ * @return module instance which has name and revision the same as are the values specified in parameters
+ * <code>name</code> and <code>revision</code>.
*/
- Module findModuleByName(String name, Date revision);
+ Optional<Module> findModule(String name, @Nullable Date revision);
+
+ default Optional<Module> findModule(final URI namespace, @Nullable final Date revision) {
+ return findModule(QNameModule.create(namespace, revision));
+ }
- default Optional<Module> findAnyModuleByName(final String name) {
- return Optional.ofNullable(findModuleByName(name, null));
+ default Optional<Module> findModule(final QNameModule qnameModule) {
+ return getModules().stream().filter(m -> qnameModule.equals(m.getQNameModule())).findAny();
+ }
+
+ /**
+ * Returns module instances (from the context) with a concrete name.
+ *
+ * @param name
+ * string with the module name
+ * @return set of module instances with specified name.
+ */
+ default Set<Module> findModules(final String name) {
+ return Sets.filter(getModules(), m -> name.equals(m.getName()));
}
/**
* @return module instance which has namespace equal to the
* <code>namespace</code> or <code>null</code> in other cases
*/
- default Set<Module> findModuleByNamespace(final URI namespace) {
+ default Set<Module> findModules(final URI namespace) {
return Sets.filter(getModules(), m -> namespace.equals(m.getNamespace()));
}
-
- /**
- * Returns module instance based on given namespace and revision. If
- * revision is not specified, returns module with newest revision.
- *
- * @param namespace Module namespace, may be null
- * @param revision Module revision, may be null
- * @return Matching module or null if a match is not found
- */
- default Module findModuleByNamespaceAndRevision(final URI namespace, final Date revision) {
- if (namespace == null) {
- return null;
- }
- for (Module module : findModuleByNamespace(namespace)) {
- if (revision == null || revision.equals(module.getRevision())) {
- return module;
- }
- }
- return null;
- }
}
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
-import java.util.Date;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Module;
final OutputStream byteArrayOutputStream = new ByteArrayOutputStream();
final BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(byteArrayOutputStream);
- final Date revision = QName.parseRevision("2017-02-28");
-
- final Module fooModule = schemaContext.findModuleByName("foo", revision);
+ final Module fooModule = schemaContext.findModule("foo", QName.parseRevision("2017-02-28")).get();
YinExportUtils.writeModuleToOutputStream(schemaContext, fooModule, bufferedOutputStream);
final String output = byteArrayOutputStream.toString();
final OutputStream byteArrayOutputStream = new ByteArrayOutputStream();
final BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(byteArrayOutputStream);
- final Date revision = QName.parseRevision("2017-02-28");
-
- final Module barModule = schemaContext.findModuleByName("bar", revision);
+ final Module barModule = schemaContext.findModule("bar", QName.parseRevision("2017-02-28")).get();
YinExportUtils.writeModuleToOutputStream(schemaContext, barModule, bufferedOutputStream);
final String output = byteArrayOutputStream.toString();
import java.util.Optional;
import org.immutables.value.Value;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
@Value.Immutable
abstract class AbstractSchemaContext extends CommonContainerSchemaNode implements SchemaContext {
@Override
- public Module findModuleByName(final String name, final Date revision) {
+ public Optional<Module> findModule(final String name, final Date revision) {
throw new UnsupportedOperationException("Not implemented");
}
}
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
import java.util.Set;
import java.util.TreeSet;
import javax.annotation.Nonnull;
return extensions;
}
+
@Override
- public Module findModuleByName(final String name, final Date revision) {
+ public Optional<Module> findModule(final String name, final Date revision) {
for (final Module module : getNameToModules().get(name)) {
- if (revision == null || revision.equals(module.getRevision())) {
- return module;
+ if (Objects.equals(revision, module.getRevision())) {
+ return Optional.of(module);
}
}
- return null;
+ return Optional.empty();
}
@Override
- public Set<Module> findModuleByNamespace(final URI namespace) {
+ public Set<Module> findModules(final URI namespace) {
final Set<Module> ret = getNamespaceToModules().get(namespace);
return ret == null ? Collections.emptySet() : ret;
}
this.qnameModule = QNameModule.create(namespace.orElse(null), revision.orElse(null));
}
+ public static ModuleIdentifier create(final String name, final Optional<Date> revision) {
+ return new ModuleIdentifierImpl(name, Optional.empty(), revision);
+ }
+
public static ModuleIdentifier create(final String name, final Optional<URI> namespace,
final Optional<Date> revision) {
return new ModuleIdentifierImpl(name, namespace, revision);
}
@Override
- public Date getRevision() {
- return qnameModule.getRevision();
+ public Optional<Date> getRevision() {
+ return Optional.ofNullable(qnameModule.getRevision());
}
@Override
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
final QName qname = schemaNode.getPath().getLastComponent();
Preconditions.checkState(qname != null, "Schema Path contains invalid state of path parts. "
+ "The Schema Path MUST contain at least ONE QName which defines namespace and Local name of path.");
- return context.findModuleByNamespaceAndRevision(qname.getNamespace(), qname.getRevision());
+ return context.findModule(qname.getModule()).orElse(null);
}
public static SchemaNode findNodeInSchemaContext(final SchemaContext context, final Iterable<QName> path) {
final QName current = path.iterator().next();
LOG.trace("Looking up module {} in context {}", current, path);
- final Module module = context.findModuleByNamespaceAndRevision(current.getNamespace(), current.getRevision());
- if (module == null) {
+ final Optional<Module> module = context.findModule(current.getModule());
+ if (!module.isPresent()) {
LOG.debug("Module {} not found", current);
return null;
}
- return findNodeInModule(module, path);
+ return findNodeInModule(module.get(), path);
}
/**
final Set<ModuleImport> imports = module.getImports();
for (final ModuleImport mi : imports) {
if (prefix.equals(mi.getPrefix())) {
- return context.findModuleByName(mi.getModuleName(), mi.getRevision());
+ return context.findModule(mi.getModuleName(), mi.getRevision()).orElse(null);
}
}
return null;
return null;
}
- final Module parentModule = schemaContext.findModuleByNamespaceAndRevision(qname.getNamespace(),
- qname.getRevision());
+ final Optional<Module> parentModule = schemaContext.findModule(qname.getModule());
+ Preconditions.checkArgument(parentModule.isPresent(), "Failed to find parent module for %s", qname);
+
final DataSchemaNode dataSchemaNode = (DataSchemaNode) SchemaContextUtil.findDataSchemaNode(schemaContext,
- parentModule, strippedPathStatement);
+ parentModule.get(), strippedPathStatement);
final TypeDefinition<?> targetTypeDefinition = typeDefinition(dataSchemaNode);
if (targetTypeDefinition instanceof LeafrefTypeDefinition) {
return getBaseTypeForLeafRef((LeafrefTypeDefinition) targetTypeDefinition, schemaContext, dataSchemaNode);
nodeType = nodeType.getBaseType();
}
- final QNameModule typeDefModuleQname = nodeType.getQName().getModule();
- return schemaContext.findModuleByNamespaceAndRevision(typeDefModuleQname.getNamespace(),
- typeDefModuleQname.getRevision());
+ return schemaContext.findModule(nodeType.getQName().getModule()).orElse(null);
}
return SchemaContextUtil.findParentModule(schemaContext, schemaNode);
//asserting collections
if (expected != null) {
for (final Module module : expected) {
- assertEquals(module, filteringSchemaContextProxy.findModuleByName(module.getName(),
- module.getRevision()));
+ assertEquals(module, filteringSchemaContextProxy.findModule(module.getName(), module.getRevision())
+ .get());
- Set<Module> mod = filteringSchemaContextProxy.findModuleByNamespace(module.getNamespace());
+ Set<Module> mod = filteringSchemaContextProxy.findModules(module.getNamespace());
assertTrue(mod.contains(module));
-
- assertEquals(module, filteringSchemaContextProxy.findModuleByNamespaceAndRevision(module.getNamespace(),
- module.getRevision()));
+ assertEquals(module, filteringSchemaContextProxy.findModule(module.getNamespace(),
+ module.getRevision()).get());
}
}
}
package org.opendaylight.yangtools.yang.model.util;
import static org.junit.Assert.assertEquals;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doReturn;
import java.util.Collections;
+import java.util.Optional;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
@Test
public void testFindDummyData() {
MockitoAnnotations.initMocks(this);
+ doReturn(Optional.empty()).when(mockSchemaContext).findModule(any(QNameModule.class));
QName qname = QName.create("TestQName");
SchemaPath schemaPath = SchemaPath.create(Collections.singletonList(qname), true);
Preconditions.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, Date, SourceSpecificContext> libSourcesTable = TreeBasedTable.create();
+ final TreeBasedTable<String, Optional<Date>, SourceSpecificContext> libSourcesTable = TreeBasedTable.create(
+ String::compareTo, ModuleIdentifier::compareRevisions);
for (final SourceSpecificContext libSource : libSources) {
final ModuleIdentifier libSourceIdentifier = Preconditions.checkNotNull(libSource.getRootIdentifier());
libSourcesTable.put(libSourceIdentifier.getName(), libSourceIdentifier.getRevision(), libSource);
}
private void collectRequiredSourcesFromLib(
- final TreeBasedTable<String, Date, SourceSpecificContext> libSourcesTable,
+ final TreeBasedTable<String, Optional<Date>, 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, Date, SourceSpecificContext> libSourcesTable) {
+ final TreeBasedTable<String, Optional<Date>, SourceSpecificContext> libSourcesTable) {
return requiredSource.getRevision() == null ? getLatestRevision(libSourcesTable.row(requiredSource.getName()))
- : libSourcesTable.get(requiredSource.getName(), QName.parseRevision(requiredSource.getRevision()));
+ : libSourcesTable.get(requiredSource.getName(),
+ Optional.of(QName.parseRevision(requiredSource.getRevision())));
}
- private static SourceSpecificContext getLatestRevision(final SortedMap<Date, SourceSpecificContext> sourceMap) {
+ private static SourceSpecificContext getLatestRevision(final SortedMap<Optional<Date>,
+ SourceSpecificContext> sourceMap) {
return sourceMap != null && !sourceMap.isEmpty() ? sourceMap.get(sourceMap.lastKey()) : null;
}
NamespaceKeyCriterion.latestRevisionModule(moduleName), SOURCE_LINKAGE);
} else {
imported = importAction.requiresCtx(stmt, ModuleNamespace.class,
- ModuleIdentifierImpl.create(moduleName, Optional.empty(), Optional.of(revision)), SOURCE_LINKAGE);
+ ModuleIdentifierImpl.create(moduleName, Optional.of(revision)), SOURCE_LINKAGE);
}
final Prerequisite<Mutable<?, ?, ?>> linkageTarget = importAction.mutatesCtx(stmt.getRoot(),
private static SemVerSourceIdentifier createSemVerModuleIdentifier(
final ModuleIdentifier importedModuleIdentifier, final SemVer semVer) {
- final String formattedRevision = SimpleDateFormatUtil.getRevisionFormat().format(
- importedModuleIdentifier.getRevision());
+ final String formattedRevision = importedModuleIdentifier.getRevision().map(
+ date -> SimpleDateFormatUtil.getRevisionFormat().format(date))
+ .orElse(null);
return SemVerSourceIdentifier.create(importedModuleIdentifier.getName(), formattedRevision, semVer);
}
}
NamespaceKeyCriterion.latestRevisionModule(submoduleName), SOURCE_LINKAGE);
} else {
requiresCtxPrerequisite = includeAction.requiresCtx(stmt, SubmoduleNamespace.class,
- ModuleIdentifierImpl.create(submoduleName, Optional.empty(),
- Optional.of(revision.getStatementArgument())), SOURCE_LINKAGE);
+ ModuleIdentifierImpl.create(submoduleName, Optional.of(revision.getStatementArgument())),
+ SOURCE_LINKAGE);
}
includeAction.apply(new InferenceAction() {
final QNameModule qNameModule = QNameModule.create(moduleNs, revisionDate.orElse(null)).intern();
stmt.addToNs(ModuleCtxToModuleQName.class, stmt, qNameModule);
- stmt.setRootIdentifier(ModuleIdentifierImpl.create(stmt.getStatementArgument(),
- Optional.empty(), revisionDate));
+ stmt.setRootIdentifier(ModuleIdentifierImpl.create(stmt.getStatementArgument(), revisionDate));
}
@Override
}
final ModuleIdentifier moduleIdentifier = ModuleIdentifierImpl.create(stmt.getStatementArgument(),
- Optional.empty(), revisionDate);
+ revisionDate);
stmt.addContext(ModuleNamespace.class, moduleIdentifier, stmt);
stmt.addContext(ModuleNamespaceForBelongsTo.class, moduleIdentifier.getName(), stmt);
final Optional<Date> revisionDate = maybeDate != null ? Optional.of(maybeDate) : DEFAULT_REVISION;
final ModuleIdentifier submoduleIdentifier = ModuleIdentifierImpl.create(stmt.getStatementArgument(),
- Optional.empty(), revisionDate);
+ revisionDate);
return submoduleIdentifier;
}
assertTrue(testSchemaContextFuture.isDone());
assertSchemaContext(testSchemaContextFuture.get(), 1);
- final Module module = testSchemaContextFuture.get().findModuleByName("foobar", null);
+ final Module module = testSchemaContextFuture.get().findModules("foobar").iterator().next();
assertNotNull(module);
assertEquals(2, module.getChildNodes().size());
assertTrue(testSchemaContextFuture.isDone());
assertSchemaContext(testSchemaContextFuture.get(), 1);
- final Module module = testSchemaContextFuture.get().findModuleByName("foobar", null);
+ final Module module = testSchemaContextFuture.get().findModules("foobar").iterator().next();
assertNotNull(module);
assertEquals(3, module.getChildNodes().size());
assertTrue(testSchemaContextFuture.isDone());
assertSchemaContext(testSchemaContextFuture.get(), 1);
- final Module module = testSchemaContextFuture.get().findModuleByName("foobar", null);
+ final Module module = testSchemaContextFuture.get().findModules("foobar").iterator().next();
assertNotNull(module);
assertEquals(1, module.getChildNodes().size());
final SchemaContext schemaContext = reactor.buildEffective();
assertNotNull(schemaContext);
- final Module testModule = schemaContext.findModuleByName("foo", QName.parseRevision("2016-09-20"));
- assertNotNull(testModule);
-
+ final Module testModule = schemaContext.findModule("foo", QName.parseRevision("2016-09-20")).get();
final LeafSchemaNode mandatoryLeaf1 = (LeafSchemaNode) testModule.getDataChildByName(
QName.create(testModule.getQNameModule(), "mandatory-leaf-1"));
assertNotNull(mandatoryLeaf1);
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import java.util.Date;
import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
final SchemaContext schemaContext = StmtTestUtils.parseYangSource("/rfc7950/bug6871/foo.yang");
assertNotNull(schemaContext);
- final Date revision = QName.parseRevision("2016-12-14");
-
- final Module foo = schemaContext.findModuleByName("foo", revision);
- assertNotNull(foo);
+ final Module foo = schemaContext.findModule("foo", QName.parseRevision("2016-12-14")).get();
final Set<NotificationDefinition> notifications = foo.getNotifications();
assertEquals(1, notifications.size());
assertNotNull(schemaContext);
// Test for valid include statement
- final Module testModule = schemaContext.findModuleByName("root-module", null);
+ final Module testModule = schemaContext.findModules("root-module").iterator().next();
assertNotNull(testModule);
// Test for valid import statement
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
-import java.util.Date;
import java.util.List;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
final SchemaContext schemaContext = StmtTestUtils.parseYangSource("/rfc7950/bug6887/foo.yang");
assertNotNull(schemaContext);
- final Date revision = QName.parseRevision("2017-01-26");
-
- final Module foo = schemaContext.findModuleByName("foo", revision);
- assertNotNull(foo);
-
+ final Module foo = schemaContext.findModule("foo", QName.parseRevision("2017-01-26")).get();
final LeafSchemaNode myEnumerationLeaf = (LeafSchemaNode) foo.getDataChildByName(
QName.create(foo.getQNameModule(), "my-enumeration-leaf"));
assertNotNull(myEnumerationLeaf);
final SchemaContext schemaContext = StmtTestUtils.parseYangSource("/rfc7950/bug6887/bar.yang");
assertNotNull(schemaContext);
- final Date revision = QName.parseRevision("2017-02-02");
-
- final Module bar = schemaContext.findModuleByName("bar", revision);
- assertNotNull(bar);
-
+ final Module bar = schemaContext.findModule("bar", QName.parseRevision("2017-02-02")).get();
final LeafSchemaNode myBitsLeaf = (LeafSchemaNode) bar.getDataChildByName(
QName.create(bar.getQNameModule(), "my-bits-leaf"));
assertNotNull(myBitsLeaf);
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
-import java.util.Date;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
final SchemaContext schemaContext = StmtTestUtils.parseYangSource("/rfc7950/bug9241/foo.yang");
assertNotNull(schemaContext);
- final Date revision = QName.parseRevision("2017-10-13");
-
- final Module fooModule = schemaContext.findModuleByName("foo", revision);
- assertNotNull(fooModule);
+ final Module fooModule = schemaContext.findModule("foo", QName.parseRevision("2017-10-13")).get();
final ContainerSchemaNode actionCont = (ContainerSchemaNode) fooModule.getDataChildByName(QName.create(
fooModule.getQNameModule(), "action-cont"));
final SchemaContext schemaContext = StmtTestUtils.parseYangSource("/rfc7950/identity-stmt/foo.yang");
assertNotNull(schemaContext);
- final Module foo = schemaContext.findModuleByName("foo", QName.parseRevision("2016-12-21"));
- assertNotNull(foo);
-
+ final Module foo = schemaContext.findModule("foo", QName.parseRevision("2016-12-21")).get();
final Set<IdentitySchemaNode> identities = foo.getIdentities();
for (final IdentitySchemaNode identity : identities) {
if ("derived-id".equals(identity.getQName().getLocalName())) {
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import java.util.Date;
import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
final SchemaContext schemaContext = StmtTestUtils.parseYangSource("/rfc7950/identityref-stmt/foo.yang");
assertNotNull(schemaContext);
- final Date revision = QName.parseRevision("2017-01-11");
-
- final Module foo = schemaContext.findModuleByName("foo", revision);
- assertNotNull(foo);
-
+ final Module foo = schemaContext.findModule("foo", QName.parseRevision("2017-01-11")).get();
final Set<IdentitySchemaNode> identities = foo.getIdentities();
assertEquals(3, identities.size());
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import java.util.Date;
import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
final SchemaContext schemaContext = StmtTestUtils.parseYangSource("/rfc7950/leafref-stmt/foo.yang");
assertNotNull(schemaContext);
- final Date revision = QName.parseRevision("2016-12-20");
-
- final Module foo = schemaContext.findModuleByName("foo", revision);
- assertNotNull(foo);
-
+ final Module foo = schemaContext.findModule("foo", QName.parseRevision("2016-12-20")).get();
final Set<TypeDefinition<?>> typeDefinitions = foo.getTypeDefinitions();
assertEquals(1, typeDefinitions.size());
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doReturn;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.text.ParseException;
import java.util.Collections;
+import java.util.Optional;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
@Test
public void testFindDummyData() {
MockitoAnnotations.initMocks(this);
+ doReturn(Optional.empty()).when(mockSchemaContext).findModule(any(QNameModule.class));
final QName qName = QName.create("TestQName");
final SchemaPath schemaPath = SchemaPath.create(Collections.singletonList(qName), true);
final SchemaContext context = TestUtils.parseYangSources("/schema-context-util-test");
- final Module myModule = context.findModuleByNamespaceAndRevision(new URI("uri:my-module"),
- QName.parseRevision("2014-10-07"));
+ final Module myModule = context.findModule(new URI("uri:my-module"), QName.parseRevision("2014-10-07")).get();
SchemaNode testNode = ((ContainerSchemaNode) myModule.getDataChildByName(QName.create(
myModule.getQNameModule(), "my-container"))).getDataChildByName(QName.create(myModule.getQNameModule(),
final SchemaContext context = TestUtils.parseYangSources("/schema-context-util-test");
- final Module myModule = context.findModuleByNamespaceAndRevision(new URI("uri:my-module"),
- QName.parseRevision("2014-10-07"));
+ final Module myModule = context.findModule(new URI("uri:my-module"), QName.parseRevision("2014-10-07")).get();
SchemaNode testNode = ((ContainerSchemaNode) myModule.getDataChildByName(QName.create(
myModule.getQNameModule(), "my-container"))).getDataChildByName(QName.create(myModule.getQNameModule(),
final SchemaContext context = TestUtils.parseYangSources("/schema-context-util-test");
- final Module myModule = context.findModuleByNamespaceAndRevision(new URI("uri:my-module"),
- QName.parseRevision("2014-10-07"));
+ final Module myModule = context.findModule(new URI("uri:my-module"), QName.parseRevision("2014-10-07")).get();
SchemaNode testNode = myModule.getDataChildByName(QName.create(myModule.getQNameModule(), "my-container"));
final SchemaContext context = TestUtils.parseYangSources("/schema-context-util-test");
- final Module myModule = context.findModuleByNamespaceAndRevision(new URI("uri:my-module"),
- QName.parseRevision("2014-10-07"));
+ final Module myModule = context.findModule(new URI("uri:my-module"), QName.parseRevision("2014-10-07")).get();
final DataSchemaNode node = myModule
.getDataChildByName(QName.create(myModule.getQNameModule(), "my-container"));
@Test
public void findDataSchemaNodeTest() throws URISyntaxException, IOException, YangSyntaxErrorException,
ReactorException {
-
final SchemaContext context = TestUtils.parseYangSources("/schema-context-util-test");
-
- final Module module = context.findModuleByNamespaceAndRevision(new URI("uri:my-module"),
- QName.parseRevision("2014-10-07"));
- final Module importedModule = context.findModuleByNamespaceAndRevision(new URI("uri:imported-module"),
- QName.parseRevision("2014-10-07"));
+ final Module module = context.findModule(new URI("uri:my-module"), QName.parseRevision("2014-10-07")).get();
+ final Module importedModule = context.findModule(new URI("uri:imported-module"),
+ QName.parseRevision("2014-10-07")).get();
final SchemaNode testNode = ((ContainerSchemaNode) importedModule.getDataChildByName(QName.create(
importedModule.getQNameModule(), "my-imported-container"))).getDataChildByName(QName.create(
// final RevisionAwareXPath nonCondXPath) {
final SchemaContext context = TestUtils.parseYangSources("/schema-context-util-test");
-
- final Module module = context.findModuleByNamespaceAndRevision(new URI("uri:my-module"),
- QName.parseRevision("2014-10-07"));
+ final Module module = context.findModule(new URI("uri:my-module"), QName.parseRevision("2014-10-07")).get();
final GroupingDefinition grouping = getGroupingByName(module, "my-grouping");
final SchemaNode testNode = grouping.getDataChildByName(QName.create(module.getQNameModule(),
YangSyntaxErrorException, ParseException, ReactorException {
final SchemaContext context = TestUtils.parseYangSources("/schema-context-util-test");
-
- final Module myModule = context.findModuleByNamespaceAndRevision(new URI("uri:my-module"),
- QName.parseRevision("2014-10-07"));
+ final Module myModule = context.findModule(new URI("uri:my-module"), QName.parseRevision("2014-10-07")).get();
// find grouping in container
DataNodeContainer dataContainer = (DataNodeContainer) myModule.getDataChildByName(QName.create(
final SchemaContext context = TestUtils.parseYangSources("/schema-context-util-test");
- final Module myModule = context.findModuleByNamespaceAndRevision(new URI("uri:my-module"),
- QName.parseRevision("2014-10-07"));
+ final Module myModule = context.findModule(new URI("uri:my-module"), QName.parseRevision("2014-10-07")).get();
// find grouping in container
DataNodeContainer dataContainer = (DataNodeContainer) myModule.getDataChildByName(QName.create(
final SchemaContext context = TestUtils.parseYangSources("/schema-context-util-test");
- final Module myModule = context.findModuleByNamespaceAndRevision(new URI("uri:my-module"),
- QName.parseRevision("2014-10-07"));
-
+ final Module myModule = context.findModule(new URI("uri:my-module"), QName.parseRevision("2014-10-07")).get();
final ChoiceSchemaNode choice = (ChoiceSchemaNode) getRpcByName(myModule, "my-name").getInput()
.getDataChildByName(QName.create(myModule.getQNameModule(), "my-choice"));
final SchemaNode testNode = choice.getCaseNodeByName("case-two").getDataChildByName(
assertNotNull(testNode);
assertNotNull(foundNode);
assertEquals(testNode, foundNode);
-
}
-
}
\ No newline at end of file
final SchemaContext root = reactor.buildEffective();
assertNotNull(root);
- final Module augmentedModule = root.findModuleByName("augmented", null);
+ final Module augmentedModule = root.findModules("augmented").iterator().next();
assertNotNull(augmentedModule);
- final ContainerSchemaNode augParent1Node = (ContainerSchemaNode) root
- .getDataChildByName(augParent1);
- final ContainerSchemaNode augParent2Node = (ContainerSchemaNode) augParent1Node
- .getDataChildByName(augParent2);
- final ContainerSchemaNode targetContNode = (ContainerSchemaNode) augParent2Node
- .getDataChildByName(contTarget);
+ final ContainerSchemaNode augParent1Node = (ContainerSchemaNode) root.getDataChildByName(augParent1);
+ final ContainerSchemaNode augParent2Node = (ContainerSchemaNode) augParent1Node.getDataChildByName(augParent2);
+ final ContainerSchemaNode targetContNode = (ContainerSchemaNode) augParent2Node.getDataChildByName(contTarget);
assertNotNull(targetContNode);
assertNotNull(targetContNode.getChildNodes());
assertEquals(3, targetContNode.getChildNodes().size());
- final ContainerSchemaNode contAdded1Node = (ContainerSchemaNode) targetContNode
- .getDataChildByName(contAdded1);
+ final ContainerSchemaNode contAdded1Node = (ContainerSchemaNode) targetContNode.getDataChildByName(contAdded1);
assertNotNull(contAdded1Node);
- final ListSchemaNode list1Node = (ListSchemaNode) contAdded1Node
- .getDataChildByName(list1);
+ final ListSchemaNode list1Node = (ListSchemaNode) contAdded1Node.getDataChildByName(list1);
assertNotNull(list1Node);
- final ContainerSchemaNode contAdded2Node = (ContainerSchemaNode) targetContNode
- .getDataChildByName(contAdded2);
+ final ContainerSchemaNode contAdded2Node = (ContainerSchemaNode) targetContNode.getDataChildByName(contAdded2);
assertNotNull(contAdded2Node);
- final AnyXmlSchemaNode axmlNode = (AnyXmlSchemaNode) contAdded2Node
- .getDataChildByName(axml);
+ final AnyXmlSchemaNode axmlNode = (AnyXmlSchemaNode) contAdded2Node.getDataChildByName(axml);
assertNotNull(axmlNode);
- final ContainerSchemaNode contGrpNode = (ContainerSchemaNode) targetContNode
- .getDataChildByName(contGrp);
+ final ContainerSchemaNode contGrpNode = (ContainerSchemaNode) targetContNode.getDataChildByName(contGrp);
assertNotNull(contGrpNode);
- final AnyXmlSchemaNode axmlGrpNode = (AnyXmlSchemaNode) contGrpNode
- .getDataChildByName(axmlGrp);
+ final AnyXmlSchemaNode axmlGrpNode = (AnyXmlSchemaNode) contGrpNode.getDataChildByName(axmlGrp);
assertNotNull(axmlGrpNode);
- final ContainerSchemaNode augCont1Node = (ContainerSchemaNode) root
- .getDataChildByName(augCont1);
- final ContainerSchemaNode augCont2Node = (ContainerSchemaNode) augCont1Node
- .getDataChildByName(augCont2);
+ final ContainerSchemaNode augCont1Node = (ContainerSchemaNode) root.getDataChildByName(augCont1);
+ final ContainerSchemaNode augCont2Node = (ContainerSchemaNode) augCont1Node.getDataChildByName(augCont2);
assertNotNull(augCont2Node);
- final ContainerSchemaNode grpCont2Node = (ContainerSchemaNode) augCont2Node
- .getDataChildByName(grpCont2);
- final ContainerSchemaNode grpCont22Node = (ContainerSchemaNode) grpCont2Node
- .getDataChildByName(grpCont22);
+ final ContainerSchemaNode grpCont2Node = (ContainerSchemaNode) augCont2Node.getDataChildByName(grpCont2);
+ final ContainerSchemaNode grpCont22Node = (ContainerSchemaNode) grpCont2Node.getDataChildByName(grpCont22);
assertNotNull(grpCont22Node);
- final ContainerSchemaNode grpAddNode = (ContainerSchemaNode) grpCont22Node
- .getDataChildByName(grpAdd);
+ final ContainerSchemaNode grpAddNode = (ContainerSchemaNode) grpCont22Node.getDataChildByName(grpAdd);
assertNotNull(grpAddNode);
}
SchemaContext schema = StmtTestUtils.parseYangSources("/bugs/bug4456");
assertNotNull(schema);
- Set<Module> modules = schema.findModuleByNamespace(new URI("foo"));
+ Set<Module> modules = schema.findModules(URI.create("foo"));
assertEquals(1, modules.size());
Module moduleFoo = modules.iterator().next();
package org.opendaylight.yangtools.yang.stmt;
+import static org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil.DEFAULT_DATE_REV;
+
import com.google.common.collect.Range;
import java.io.File;
+import java.net.URI;
import java.util.List;
import org.junit.Assert;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
// when
final SchemaContext schemaContext = TestUtils.parseYangSources(extdef, stringWithExt);
- final LeafSchemaNode leaf = (LeafSchemaNode) schemaContext.findModuleByName("types", null).getDataChildByName(
- QName.create("urn:custom.types.demo", "1970-01-01", "leaf-length-pattern-unknown"));
+ final LeafSchemaNode leaf = (LeafSchemaNode) typesModule(schemaContext).getDataChildByName(
+ QName.create(URI.create("urn:custom.types.demo"), DEFAULT_DATE_REV, "leaf-length-pattern-unknown"));
// then
Assert.assertNotNull(leaf);
final UnknownSchemaNode unknownSchemaNode = unknownSchemaNodes.get(0);
Assert.assertEquals(unknownSchemaNode.getNodeParameter(), "unknown");
- Assert.assertEquals(unknownSchemaNode.getNodeType().getModule().getNamespace().toString(), "urn:simple.extension.typedefs");
+ Assert.assertEquals(unknownSchemaNode.getNodeType().getModule().getNamespace().toString(),
+ "urn:simple.extension.typedefs");
final LengthConstraint lengthConstraint = ((StringTypeDefinition) type).getLengthConstraint().get();
final List<PatternConstraint> patternConstraints = ((StringTypeDefinition) type).getPatternConstraints();
// when
final SchemaContext schemaContext = TestUtils.parseYangSources(extdef, stringWithExt);
- final LeafSchemaNode leaf = (LeafSchemaNode) schemaContext.findModuleByName("types", null).getDataChildByName(
- QName.create("urn:custom.types.demo", "1970-01-01", "leaf-length-unknown-pattern"));
+ final LeafSchemaNode leaf = (LeafSchemaNode) typesModule(schemaContext).getDataChildByName(
+ QName.create(URI.create("urn:custom.types.demo"), DEFAULT_DATE_REV, "leaf-length-unknown-pattern"));
// then
Assert.assertNotNull(leaf);
final UnknownSchemaNode unknownSchemaNode = unknownSchemaNodes.get(0);
Assert.assertEquals(unknownSchemaNode.getNodeParameter(), "unknown");
- Assert.assertEquals(unknownSchemaNode.getNodeType().getModule().getNamespace().toString(), "urn:simple.extension.typedefs");
+ Assert.assertEquals(unknownSchemaNode.getNodeType().getModule().getNamespace().toString(),
+ "urn:simple.extension.typedefs");
final LengthConstraint lengthConstraints = ((StringTypeDefinition) type).getLengthConstraint().get();
final List<PatternConstraint> patternConstraints = ((StringTypeDefinition) type).getPatternConstraints();
// when
final SchemaContext schemaContext = TestUtils.parseYangSources(extdef, stringWithExt);
- final LeafSchemaNode leaf = (LeafSchemaNode) schemaContext.findModuleByName("types", null).getDataChildByName(
- QName.create("urn:custom.types.demo", "1970-01-01", "leaf-unknown-length-pattern"));
+ final LeafSchemaNode leaf = (LeafSchemaNode) typesModule(schemaContext).getDataChildByName(
+ QName.create(URI.create("urn:custom.types.demo"), DEFAULT_DATE_REV, "leaf-unknown-length-pattern"));
// then
Assert.assertNotNull(leaf);
final UnknownSchemaNode unknownSchemaNode = unknownSchemaNodes.get(0);
Assert.assertEquals(unknownSchemaNode.getNodeParameter(), "unknown");
- Assert.assertEquals(unknownSchemaNode.getNodeType().getModule().getNamespace().toString(), "urn:simple.extension.typedefs");
+ Assert.assertEquals(unknownSchemaNode.getNodeType().getModule().getNamespace().toString(),
+ "urn:simple.extension.typedefs");
final LengthConstraint lengthConstraints =
((StringTypeDefinition) type).getLengthConstraint().get();
final PatternConstraint patternConstraint = patternConstraints.get(0);
Assert.assertEquals(patternConstraint.getRegularExpression(), "^[0-9a-fA-F]$");
}
+
+ private static Module typesModule(final SchemaContext context) {
+ return context.findModules("types").iterator().next();
+ }
}
\ No newline at end of file
SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug4933/correct");
assertNotNull(context);
- final Module foo = context.findModuleByName("foo", null);
-
+ final Module foo = context.findModules("foo").iterator().next();
Set<Deviation> deviations = foo.getDeviations();
assertEquals(4, deviations.size());
}
SchemaContext schemaContext = StmtTestUtils.parseYangSources("/bugs/bug5712");
assertNotNull(schemaContext);
- Module badModule = schemaContext.findModuleByName("bad", null);
+ Module badModule = schemaContext.findModules("bad").iterator().next();
assertNotNull(badModule);
-
checkThing2TypeDef(badModule);
}
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import java.util.Date;
import java.util.Iterator;
import java.util.Set;
import org.junit.Test;
final QName root = QName.create(NS, REV, "main-container");
final QName choice = QName.create(NS, REV, "test-choice");
final QName testContainerQname = QName.create(NS, REV, "test");
- final Date date = QName.parseRevision("2016-01-01");
- final Module foo = context.findModuleByName("foo", date);
+ final Module foo = context.findModule("foo", QName.parseRevision("2016-01-01")).get();
final ContainerSchemaNode rootContainer = (ContainerSchemaNode) context.getDataChildByName(root);
final ContainerSchemaNode testContainer = (ContainerSchemaNode) rootContainer.getDataChildByName(
testContainerQname);
throws Exception {
final SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug6491/".concat(path));
assertNotNull(context);
- final Module module = context.findModuleByName("bar", moduleRevision);
- assertNotNull(module);
+ final Module module = context.findModule("bar", moduleRevision).get();
final Set<ModuleImport> imports = module.getImports();
assertNotNull(imports);
assertEquals(1, imports.size());
assertEquals(3, schemaContext.getModules().size());
final Date revision = QName.parseRevision("2016-10-20");
-
- final Module foo = schemaContext.findModuleByName("foo", revision);
- assertNotNull(foo);
- final Module bar = schemaContext.findModuleByName("bar", revision);
- assertNotNull(bar);
- final Module baz = schemaContext.findModuleByName("baz", revision);
- assertNotNull(baz);
+ final Module foo = schemaContext.findModule("foo", revision).get();
+ final Module bar = schemaContext.findModule("bar", revision).get();
+ final Module baz = schemaContext.findModule("baz", revision).get();
final QName barExportCont = QName.create("bar-ns", "bar-export", revision);
final QName barFooCont = QName.create("bar-ns", "bar-foo", revision);
assertNotNull(schemaContext);
final Date revision = QName.parseRevision("2016-12-23");
-
- final Module foo = schemaContext.findModuleByName("foo", revision);
- assertNotNull(foo);
- final Module bar = schemaContext.findModuleByName("bar", revision);
- assertNotNull(bar);
+ final Module foo = schemaContext.findModule("foo", revision).get();
+ final Module bar = schemaContext.findModule("bar", revision).get();
final Set<Deviation> deviations = foo.getDeviations();
assertEquals(1, deviations.size());
final Set<Module> modules = context.getModules();
assertEquals(8, modules.size());
- assertNotNull(context.findModuleByNamespaceAndRevision(new URI("foo-imp"), QName.parseRevision("2017-01-23")));
- assertEquals(1, context.findModuleByNamespace(new URI("foo-imp-2")).size());
- assertEquals(1, context.findModuleByNamespace(new URI("foo-imp-imp")).size());
- assertEquals(1, context.findModuleByNamespace(new URI("bar")).size());
- assertEquals(1, context.findModuleByNamespace(new URI("baz")).size());
- assertNotNull(context.findModuleByNamespaceAndRevision(new URI("baz-imp"), QName.parseRevision("2002-01-01")));
- final Set<Module> foo = context.findModuleByNamespace(new URI("foo"));
+ assertNotNull(context.findModule(new URI("foo-imp"), QName.parseRevision("2017-01-23")));
+ assertEquals(1, context.findModules(new URI("foo-imp-2")).size());
+ assertEquals(1, context.findModules(new URI("foo-imp-imp")).size());
+ assertEquals(1, context.findModules(new URI("bar")).size());
+ assertEquals(1, context.findModules(new URI("baz")).size());
+ assertTrue(context.findModule(new URI("baz-imp"), QName.parseRevision("2002-01-01")).isPresent());
+ final Set<Module> foo = context.findModules(new URI("foo"));
assertEquals(1, foo.size());
final Set<Module> subFoos = foo.iterator().next().getSubmodules();
assertEquals(1, subFoos.size());
- final Module parentMod = context.findModuleByNamespaceAndRevision(new URI("parent-mod-ns"),
- QName.parseRevision("2017-09-07"));
- assertNotNull(parentMod);
+ final Module parentMod = context.findModule(new URI("parent-mod-ns"), QName.parseRevision("2017-09-07")).get();
assertEquals(1, parentMod.getSubmodules().size());
}
import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
final SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug8597");
assertNotNull(context);
- final Module foo = context.findModuleByName("foo", QName.parseRevision("1970-01-01"));
- assertNotNull(foo);
-
+ final Module foo = context.findModule("foo", SimpleDateFormatUtil.DEFAULT_DATE_REV).get();
final Set<ModuleImport> imports = foo.getImports();
for (final ModuleImport moduleImport : imports) {
final SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug9005");
assertNotNull(context);
- final Module foo = context.findModuleByName("foo", QName.parseRevision("2017-07-07"));
+ final Module foo = context.findModule("foo", QName.parseRevision("2017-07-07")).get();
final Set<ModuleImport> imports = foo.getImports();
assertEquals(1, imports.size());
final Date revision = QName.parseRevision("2017-10-13");
- final Module rootModule = schemaContext.findModuleByName("root-module", revision);
- final Module impModule = schemaContext.findModuleByName("imp-module", revision);
- assertNotNull(impModule);
+ final Module rootModule = schemaContext.findModule("root-module", revision).get();
+ final Module impModule = schemaContext.findModule("imp-module", revision).get();
TypeDefinition<?> deviatedMyLeafType = null;
TypeDefinition<?> deviatedMyLeaf2Type = null;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
-import java.util.Date;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
final SchemaContext schemaContext = StmtTestUtils.parseYangSources("/bugs/bug9244/");
assertNotNull(schemaContext);
- final Date revision = QName.parseRevision("2017-10-13");
-
- final Module barModule = schemaContext.findModuleByName("bar", revision);
- assertNotNull(barModule);
-
+ final Module barModule = schemaContext.findModule("bar", QName.parseRevision("2017-10-13")).get();
final ContainerSchemaNode barCont = (ContainerSchemaNode) barModule.getDataChildByName(
QName.create(barModule.getQNameModule(), "bar-cont"));
assertNotNull(barCont);
String date_s = "2015-09-09 00:00:00.0";
SimpleDateFormat dt = SimpleDateFormatUtil.getRevisionFormat();
Date date = dt.parse(date_s);
- rootFoo = schema.findModuleByName("foo", date);
- rootBar = schema.findModuleByName("bar", date);
+ rootFoo = schema.findModule("foo", date).get();
+ rootBar = schema.findModule("bar", date).get();
assertNotNull(rootFoo);
assertNotNull(rootBar);
qnameFoo = QNameModule.create(URI.create("foo"), date);
final SchemaContext result = reactor.buildEffective();
assertNotNull(result);
- final Module testModule = result.findModuleByName("foo", null);
+ final Module testModule = result.findModules("foo").iterator().next();
assertNotNull(testModule);
final ContainerSchemaNode container = (ContainerSchemaNode) testModule.getDataChildByName(QName.create(
private static void salDomBrokerImplModuleTest(final SchemaContext context)
throws ParseException {
- final Module module = context.findModuleByName("opendaylight-sal-dom-broker-impl",
- QName.parseRevision("2013-10-28"));
- assertNotNull(module);
+ final Module module = context.findModule("opendaylight-sal-dom-broker-impl",
+ QName.parseRevision("2013-10-28")).get();
final Set<AugmentationSchema> augmentations = module.getAugmentations();
boolean checked = false;
final ContainerSchemaNode containerNode = (ContainerSchemaNode) dataNode2;
final DataSchemaNode leaf = containerNode
.getDataChildByName(QName.create(module.getQNameModule(), "type"));
- final List<UnknownSchemaNode> unknownSchemaNodes = leaf
- .getUnknownSchemaNodes();
+ final List<UnknownSchemaNode> unknownSchemaNodes = leaf.getUnknownSchemaNodes();
assertEquals(1, unknownSchemaNodes.size());
- final UnknownSchemaNode unknownSchemaNode = unknownSchemaNodes
- .get(0);
- assertEquals("dom-async-data-broker", unknownSchemaNode
- .getQName().getLocalName());
- assertEquals(unknownSchemaNode.getQName(),
- unknownSchemaNode.getPath().getLastComponent());
+ final UnknownSchemaNode unknownSchemaNode = unknownSchemaNodes.get(0);
+ assertEquals("dom-async-data-broker", unknownSchemaNode.getQName().getLocalName());
+ assertEquals(unknownSchemaNode.getQName(), unknownSchemaNode.getPath().getLastComponent());
checked = true;
}
private static void configModuleTest(final SchemaContext context) throws ParseException,
URISyntaxException {
- final Module configModule = context.findModuleByName("config", QName.parseRevision("2013-04-05"));
- assertNotNull(configModule);
-
- final Module module = context.findModuleByName(
- "opendaylight-sal-dom-broker-impl", QName.parseRevision("2013-10-28"));
- assertNotNull(module);
+ final Module configModule = context.findModule("config", QName.parseRevision("2013-04-05")).get();
+ final Module module = context.findModule("opendaylight-sal-dom-broker-impl",
+ QName.parseRevision("2013-10-28")).get();
final DataSchemaNode dataNode = configModule.getDataChildByName(QName.create(configModule.getQNameModule(),
"modules"));
assertTrue(dataChildChoice instanceof ChoiceSchemaNode);
final ChoiceSchemaNode confChoice = (ChoiceSchemaNode) dataChildChoice;
- final ChoiceCaseNode caseNodeByName = confChoice
- .getCaseNodeByName("dom-broker-impl");
+ final ChoiceCaseNode caseNodeByName = confChoice.getCaseNodeByName("dom-broker-impl");
assertNotNull(caseNodeByName);
final DataSchemaNode dataNode2 = caseNodeByName
final ContainerSchemaNode containerNode = (ContainerSchemaNode) dataNode2;
final DataSchemaNode leaf = containerNode.getDataChildByName(QName.create(module.getQNameModule(), "type"));
- final List<UnknownSchemaNode> unknownSchemaNodes = leaf
- .getUnknownSchemaNodes();
+ final List<UnknownSchemaNode> unknownSchemaNodes = leaf.getUnknownSchemaNodes();
assertEquals(1, unknownSchemaNodes.size());
final UnknownSchemaNode unknownSchemaNode = unknownSchemaNodes.get(0);
- assertEquals(unknownSchemaNode.getQName(), unknownSchemaNode.getPath()
- .getLastComponent());
- assertEquals("dom-async-data-broker", unknownSchemaNode.getQName()
- .getLocalName());
+ assertEquals(unknownSchemaNode.getQName(), unknownSchemaNode.getPath().getLastComponent());
+ assertEquals("dom-async-data-broker", unknownSchemaNode.getQName().getLocalName());
- final ChoiceCaseNode domInmemoryDataBroker = confChoice
- .getCaseNodeByName("dom-inmemory-data-broker");
+ final ChoiceCaseNode domInmemoryDataBroker = confChoice.getCaseNodeByName("dom-inmemory-data-broker");
assertNotNull(domInmemoryDataBroker);
final DataSchemaNode schemaService = domInmemoryDataBroker
final SchemaContext schemaContext = StmtTestUtils.parseYangSources(anyxmlStmtModule);
assertNotNull(schemaContext);
- final Module testModule = schemaContext.findModuleByName("anyxml-declared-test", null);
+ final Module testModule = schemaContext.findModules("anyxml-declared-test").iterator().next();
assertNotNull(testModule);
final AnyXmlSchemaNode anyxmlSchemaNode = (AnyXmlSchemaNode) testModule.getDataChildByName(
final SchemaContext schemaContext = StmtTestUtils.parseYangSources(choiceStmtModule);
assertNotNull(schemaContext);
- final Module testModule = schemaContext.findModuleByName("choice-declared-test", null);
+ final Module testModule = schemaContext.findModules("choice-declared-test").iterator().next();
assertNotNull(testModule);
final ChoiceSchemaNode choiceSchemaNode = (ChoiceSchemaNode) testModule.getDataChildByName(
final SchemaContext schemaContext = StmtTestUtils.parseYangSources(augmentStmtModule);
assertNotNull(schemaContext);
- final Module testModule = schemaContext.findModuleByName("augment-declared-test", null);
+ final Module testModule = schemaContext.findModules("augment-declared-test").iterator().next();
assertNotNull(testModule);
final Set<AugmentationSchema> augmentationSchemas = testModule.getAugmentations();
final SchemaContext schemaContext = StmtTestUtils.parseYangSources(parentModule, childModule);
assertNotNull(schemaContext);
- final Module testModule = schemaContext.findModuleByName("parent-module-declared-test", null);
+ final Module testModule = schemaContext.findModules("parent-module-declared-test").iterator().next();
assertNotNull(testModule);
final ModuleStatement moduleStatement = ((ModuleEffectiveStatementImpl) testModule).getDeclared();
final Date revision = QName.parseRevision("2016-09-28");
- final Module testModule = schemaContext.findModuleByName("root-module-declared-test", revision);
+ final Module testModule = schemaContext.findModule("root-module-declared-test", revision).get();
assertNotNull(testModule);
final ModuleStatement moduleStatement = ((ModuleEffectiveStatementImpl) testModule).getDeclared();
final SchemaContext schemaContext = StmtTestUtils.parseYangSources(containerStmtModule);
assertNotNull(schemaContext);
- final Module testModule = schemaContext.findModuleByName("container-declared-test", null);
+ final Module testModule = schemaContext.findModules("container-declared-test").iterator().next();
assertNotNull(testModule);
final ContainerSchemaNode containerSchemaNode = (ContainerSchemaNode) testModule.getDataChildByName(
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
-import java.util.Date;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
"/deviation-resolution-test/deviation-not-supported");
assertNotNull(schemaContext);
- final Date revision = QName.parseRevision("2017-01-20");
-
- final Module importedModule = schemaContext.findModuleByName("imported", revision);
- assertNotNull(importedModule);
-
+ final Module importedModule = schemaContext.findModule("imported", QName.parseRevision("2017-01-20")).get();
final ContainerSchemaNode myContA = (ContainerSchemaNode) importedModule.getDataChildByName(
QName.create(importedModule.getQNameModule(), "my-cont-a"));
assertNotNull(myContA);
sourceForResource("/deviation-resolution-test/deviation-add/bar.yang"));
assertNotNull(schemaContext);
- final Module barModule = schemaContext.findModuleByName("bar", QName.parseRevision("2017-01-20"));
- assertNotNull(barModule);
-
+ final Module barModule = schemaContext.findModule("bar", QName.parseRevision("2017-01-20")).get();
final LeafListSchemaNode myLeafList = (LeafListSchemaNode) barModule.getDataChildByName(
QName.create(barModule.getQNameModule(), "my-leaf-list"));
assertNotNull(myLeafList);
sourceForResource("/deviation-resolution-test/deviation-replace/bar.yang"));
assertNotNull(schemaContext);
- final Date revision = QName.parseRevision("2017-01-20");
-
- final Module barModule = schemaContext.findModuleByName("bar", revision);
+ final Module barModule = schemaContext.findModule("bar", QName.parseRevision("2017-01-20")).get();
assertNotNull(barModule);
final LeafSchemaNode myLeaf = (LeafSchemaNode) barModule.getDataChildByName(
sourceForResource("/deviation-resolution-test/deviation-delete/bar.yang"));
assertNotNull(schemaContext);
- final Date revision = QName.parseRevision("2017-01-20");
-
- final Module barModule = schemaContext.findModuleByName("bar", revision);
- assertNotNull(barModule);
-
+ final Module barModule = schemaContext.findModule("bar", QName.parseRevision("2017-01-20")).get();
final LeafSchemaNode myLeaf = (LeafSchemaNode) barModule.getDataChildByName(
QName.create(barModule.getQNameModule(), "my-leaf"));
assertNotNull(myLeaf);
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
import java.text.ParseException;
-import java.util.Date;
import java.util.List;
import java.util.Set;
import org.junit.Test;
final SchemaContext schemaContext = reactor.buildEffective();
assertNotNull(schemaContext);
- Date revision = QName.parseRevision("2016-06-23");
-
- Module testModule = schemaContext.findModuleByName("foo", revision);
- assertNotNull(testModule);
-
+ Module testModule = schemaContext.findModule("foo", QName.parseRevision("2016-06-23")).get();
Set<Deviation> deviations = testModule.getDeviations();
assertEquals(4, deviations.size());
}
}
- revision = QName.parseRevision("2016-09-22");
- testModule = schemaContext.findModuleByName("bar", revision);
+ testModule = schemaContext.findModule("bar", QName.parseRevision("2016-09-22")).get();
assertNotNull(testModule);
deviations = testModule.getDeviations();
assertNotNull(result);
- Module simpleModule = result.findModuleByName("simple-module", null);
+ Module simpleModule = result.findModules("simple-module").iterator().next();
assertNotNull(simpleModule);
QName q1 = QName.create(SIMPLE_MODULE_QNAME, "root-container");
assertNotNull(result);
- Module module = result.findModuleByName("identity-test",
- SimpleDateFormatUtil.DEFAULT_DATE_REV);
-
- assertNotNull(module);
-
+ Module module = result.findModule("identity-test", SimpleDateFormatUtil.DEFAULT_DATE_REV).get();
Set<IdentitySchemaNode> identities = module.getIdentities();
assertNotNull(identities);
assertNotNull(result);
- Module rootModule = result.findModuleByName("root", null);
+ Module rootModule = result.findModules("root").iterator().next();
assertNotNull(rootModule);
assertEquals("root-pref", rootModule.getPrefix());
private static void findModulesSubTest(final SchemaContext result, final Module root, final Module imported)
throws URISyntaxException {
- final Module foundRoot = result.findModuleByName("root-module",
- SimpleDateFormatUtil.DEFAULT_DATE_REV);
- final Set<Module> foundRoots = result.findModuleByNamespace(new URI(
- "root-module"));
- final Module foundRoot3 = result.findModuleByNamespaceAndRevision(new URI(
- "root-module"), SimpleDateFormatUtil.DEFAULT_DATE_REV);
+ final Module foundRoot = result.findModule("root-module", SimpleDateFormatUtil.DEFAULT_DATE_REV).get();
+ final Set<Module> foundRoots = result.findModules(new URI("root-module"));
+ final Module foundRoot3 = result.findModule(new URI("root-module"), SimpleDateFormatUtil.DEFAULT_DATE_REV)
+ .get();
assertNotNull(foundRoot);
assertNotNull(foundRoots);
assertEquals(root, foundRoot2);
assertEquals(root, foundRoot3);
- final Module foundImported = result.findModuleByName("imported-module",
- SimpleDateFormatUtil.DEFAULT_DATE_REV);
- final Set<Module> foundImporteds = result.findModuleByNamespace(new URI(
- "imported-module"));
- final Module foundImported3 = result.findModuleByNamespaceAndRevision(
- new URI("imported-module"),
- SimpleDateFormatUtil.DEFAULT_DATE_REV);
+ final Module foundImported = result.findModule("imported-module", SimpleDateFormatUtil.DEFAULT_DATE_REV).get();
+ final Set<Module> foundImporteds = result.findModules(new URI("imported-module"));
+ final Module foundImported3 = result.findModule(new URI("imported-module"),
+ SimpleDateFormatUtil.DEFAULT_DATE_REV).get();
assertNotNull(foundImported);
assertNotNull(foundImporteds);
assertNull(schemaContext.getDataChildByName(QName.create("foo-namespace", "2016-09-21", "foo-cont")));
- assertNull(schemaContext.findModuleByName("foo", QName.parseRevision("2016-08-21")));
- assertNull(schemaContext.findModuleByNamespaceAndRevision(null, QName.parseRevision("2016-09-21")));
- assertNull(schemaContext.findModuleByNamespaceAndRevision(URI.create("foo-namespace"),
- QName.parseRevision("2016-08-21")));
+ assertFalse(schemaContext.findModule("foo", QName.parseRevision("2016-08-21")).isPresent());
+ assertFalse(schemaContext.findModule(URI.create("foo-namespace"), QName.parseRevision("2016-08-21"))
+ .isPresent());
assertFalse(schemaContext.isAugmenting());
assertFalse(schemaContext.isAddedByUses());
assertNotNull(schemaContext.getAvailableAugmentations());
assertTrue(schemaContext.getAvailableAugmentations().isEmpty());
- Module fooModule = schemaContext.findModuleByName("foo", QName.parseRevision("2016-09-21"));
- assertNotNull(fooModule);
-
+ Module fooModule = schemaContext.findModule("foo", QName.parseRevision("2016-09-21")).get();
assertEquals(3, schemaContext.getModules().size());
assertEquals(3, ((EffectiveSchemaContext) schemaContext).getRootDeclaredStatements().size());
assertEquals(3,((EffectiveSchemaContext) schemaContext).getRootEffectiveStatements().size());
final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
reactor.addSource(IMPORTED_MODULE);
effectiveSchemaContext = reactor.buildEffective();
- types = effectiveSchemaContext.findModuleByName("types", null);
+ types = effectiveSchemaContext.findModules("types").iterator().next();
assertNotNull(types);
}
final SchemaContext result = reactor.buildEffective();
assertNotNull(result);
- final Module testModule = result.findModuleByName("bar", null);
+ final Module testModule = result.findModules("bar").iterator().next();
assertNotNull(testModule);
assertEquals(1, testModule.getExtensionSchemaNodes().size());
final SchemaContext result = reactor.buildEffective();
assertNotNull(result);
- final Module testModule1 = result.findModuleByName("ext-typedef", null);
+ final Module testModule1 = result.findModules("ext-typedef").iterator().next();
assertNotNull(testModule1);
assertEquals(1, testModule1.getExtensionSchemaNodes().size());
final List<ExtensionDefinition> extensions = testModule1.getExtensionSchemaNodes();
final ExtensionDefinition extensionDefinition = extensions.get(0);
- final Module testModule2 = result.findModuleByName("ext-use", null);
+ final Module testModule2 = result.findModules("ext-use").iterator().next();
assertNotNull(testModule2);
final LeafSchemaNode leaf = (LeafSchemaNode) testModule2.getDataChildByName(QName.create(testModule2.getQNameModule(), "value"));
final SchemaContext result = reactor.buildEffective();
assertNotNull(result);
- final Module testModule = result.findModuleByName("baz", null);
+ final Module testModule = result.findModules("baz").iterator().next();
assertNotNull(testModule);
final Set<GroupingDefinition> groupings = testModule.getGroupings();
final SchemaContext result = reactor.buildEffective();
assertNotNull(result);
- final Module testModule = result.findModuleByName("foo", null);
+ final Module testModule = result.findModules("foo").iterator().next();
assertNotNull(testModule);
final Set<UsesNode> usesNodes = testModule.getUses();
SchemaContext result = reactor.buildEffective();
assertNotNull(result);
- Module testModule = result.findModuleByName("legal-chained-identity-test", null);
+ Module testModule = result.findModules("legal-chained-identity-test").iterator().next();
assertNotNull(testModule);
Set<IdentitySchemaNode> identities = testModule.getIdentities();
SchemaContext result = reactor.buildEffective();
assertNotNull(result);
- Module testModule = result.findModuleByName("duplicate-identity-test", null);
+ Module testModule = result.findModules("duplicate-identity-test").iterator().next();
Set<IdentitySchemaNode> identities = testModule.getIdentities();
assertEquals(1, identities.size());
}
final SchemaContext schemaContext = reactor.buildEffective();
assertNotNull(schemaContext);
- final Module testModule = schemaContext.findModuleByName("foo", null);
+ final Module testModule = schemaContext.findModules("foo").iterator().next();
assertNotNull(testModule);
assertEquals(9, testModule.getChildNodes().size());
final SchemaContext schemaContext = reactor.buildEffective();
assertNotNull(schemaContext);
- final Module testModule = schemaContext.findModuleByName("foo", null);
+ final Module testModule = schemaContext.findModules("foo").iterator().next();
assertNotNull(testModule);
assertEquals(11, testModule.getChildNodes().size());
final SchemaContext schemaContext = reactor.buildEffective();
assertNotNull(schemaContext);
- final Module testModule = schemaContext.findModuleByName("foo", null);
+ final Module testModule = schemaContext.findModules("foo").iterator().next();
assertNotNull(testModule);
assertEquals(6, testModule.getChildNodes().size());
import java.util.Iterator;
import java.util.Set;
+import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
private static final StatementStreamSource CHILD_MODULE = sourceForResource(
"/included-statements-test/child-module.yang");
- @Test
- public void includedTypedefsTest() throws ReactorException {
+ private SchemaContext result;
+
+ @Before
+ public void setup() throws ReactorException {
final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
reactor.addSources(ROOT_MODULE, CHILD_MODULE);
+ result = reactor.buildEffective();
+ }
- final SchemaContext result = reactor.buildEffective();
- assertNotNull(result);
-
- final Module testModule = result.findModuleByName("root-module", null);
+ @Test
+ public void includedTypedefsTest() {
+ final Module testModule = result.findModules("root-module").iterator().next();
assertNotNull(testModule);
final Set<TypeDefinition<?>> typedefs = testModule.getTypeDefinitions();
}
@Test
- public void includedFeaturesTest() throws ReactorException {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(ROOT_MODULE, CHILD_MODULE);
-
- final SchemaContext result = reactor.buildEffective();
- assertNotNull(result);
-
- final Module testModule = result.findModuleByName("root-module", null);
+ public void includedFeaturesTest() {
+ final Module testModule = result.findModules("root-module").iterator().next();
assertNotNull(testModule);
final Set<FeatureDefinition> features = testModule.getFeatures();
}
@Test
- public void includedContainersAndListsTest() throws ReactorException {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(ROOT_MODULE, CHILD_MODULE);
-
- final SchemaContext result = reactor.buildEffective();
- assertNotNull(result);
-
- final Module testModule = result.findModuleByName("root-module", null);
+ public void includedContainersAndListsTest() {
+ final Module testModule = result.findModules("root-module").iterator().next();
assertNotNull(testModule);
ContainerSchemaNode cont = (ContainerSchemaNode) testModule.getDataChildByName(QName.create(testModule.getQNameModule(), "parent-container"));
}
@Test
- public void submoduleNamespaceTest() throws ReactorException {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild();
- reactor.addSources(ROOT_MODULE, CHILD_MODULE);
-
- final SchemaContext result = reactor.buildEffective();
- assertNotNull(result);
-
- final Module testModule = result.findModuleByName("root-module", null);
+ public void submoduleNamespaceTest() {
+ final Module testModule = result.findModules("root-module").iterator().next();
assertNotNull(testModule);
final Module subModule = testModule.getSubmodules().iterator().next();
final SchemaContext result = reactor.buildEffective();
assertNotNull(result);
- final Module testModule = result.findModuleByName("list-test", null);
+ final Module testModule = result.findModules("list-test").iterator().next();
assertNotNull(testModule);
- final ListSchemaNode list = (ListSchemaNode) testModule.getDataChildByName(QName.create(testModule.getQNameModule(), "simple-list"));
+ final ListSchemaNode list = (ListSchemaNode) testModule.getDataChildByName(
+ QName.create(testModule.getQNameModule(), "simple-list"));
assertNotNull(list);
assertTrue(list.isUserOrdered());
assertEquals(5, list.getChildNodes().size());
- LeafSchemaNode leaf = (LeafSchemaNode) list.getDataChildByName(QName.create(testModule.getQNameModule(), "key1"));
+ LeafSchemaNode leaf = (LeafSchemaNode) list.getDataChildByName(QName.create(testModule.getQNameModule(),
+ "key1"));
assertNotNull(leaf);
assertTrue(leaf.getConstraints().isMandatory());
assertEquals("int32", leaf.getType().getQName().getLocalName());
assertEquals("young-leaf", leaf.getType().getQName().getLocalName());
assertEquals("default-value", leaf.getDefault());
- final LeafListSchemaNode leafList = (LeafListSchemaNode) list.getDataChildByName(QName.create(testModule.getQNameModule(), "list-of-leaves"));
+ final LeafListSchemaNode leafList = (LeafListSchemaNode) list.getDataChildByName(
+ QName.create(testModule.getQNameModule(), "list-of-leaves"));
assertNotNull(leafList);
assertTrue(leafList.getConstraints().isMandatory());
assertTrue(leafList.isUserOrdered());
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
+import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
private static void checkContentFullTest(final SchemaContext context) {
URI yangTypesNS = URI.create("urn:ietf:params:xml:ns:yang:ietf-yang-types");
- Date rev20100924 = QName.parseRevision("2010-09-24");
- Date rev20130516 = QName.parseRevision("2013-05-16");
- Date rev20130715 = QName.parseRevision("2013-07-15");
+ final Date rev20100924 = QName.parseRevision("2010-09-24");
+ final Date rev20130516 = QName.parseRevision("2013-05-16");
+ final Date rev20130715 = QName.parseRevision("2013-07-15");
final QNameModule yangTypes_20100924 = QNameModule.create(yangTypesNS, rev20100924);
final QNameModule yangTypes_20130516 = QNameModule.create(yangTypesNS, rev20130516);
final QName dateTimeTypeDef_20130516 = QName.create(yangTypes_20130516, "date-and-time");
final QName dateTimeTypeDef_20130715 = QName.create(yangTypes_20130715, "date-and-time");
- Module yangTypesModule_20100924 = context.findModuleByName("ietf-yang-types", rev20100924);
- Module yangTypesModule_20130516 = context.findModuleByName("ietf-yang-types", rev20130516);
- Module yangTypesModule_20130715 = context.findModuleByName("ietf-yang-types", rev20130715);
-
- assertNotNull(yangTypesModule_20100924);
- assertNotNull(yangTypesModule_20130516);
- assertNotNull(yangTypesModule_20130715);
-
+ Module yangTypesModule_20100924 = context.findModule("ietf-yang-types", rev20100924).get();
+ Module yangTypesModule_20130516 = context.findModule("ietf-yang-types", rev20130516).get();
+ Module yangTypesModule_20130715 = context.findModule("ietf-yang-types", rev20130715).get();
assertTrue(findTypeDef(yangTypesModule_20100924, dateTimeTypeDef_20100924));
assertTrue(findTypeDef(yangTypesModule_20130516, dateTimeTypeDef_20130516));
assertTrue(findTypeDef(yangTypesModule_20130715, dateTimeTypeDef_20130715));
final QName dateTimeTypeDef_20100924) {
Date rev20121115 = QName.parseRevision("2012-11-15");
- Module interfacesModule_20121115 = context.findModuleByName("ietf-interfaces", rev20121115);
- assertNotNull(interfacesModule_20121115);
-
+ Module interfacesModule_20121115 = context.findModule("ietf-interfaces", rev20121115).get();
Set<ModuleImport> imports = interfacesModule_20121115.getImports();
assertEquals(1, imports.size());
ModuleImport interfacesImport = imports.iterator().next();
final Date rev20130715, final QName dateTimeTypeDef_20130715) {
Date rev20101004 = QName.parseRevision("2010-10-04");
- Module monitoringModule_20101004 = context.findModuleByName("ietf-netconf-monitoring", rev20101004);
- assertNotNull(monitoringModule_20101004);
-
+ Module monitoringModule_20101004 = context.findModule("ietf-netconf-monitoring", rev20101004).get();
Set<ModuleImport> imports = monitoringModule_20101004.getImports();
assertEquals(2, imports.size());
for (ModuleImport monitoringImport : imports) {
private static void checkContentSimpleTest(final SchemaContext context) {
URI yangTypesNS = URI.create("urn:ietf:params:xml:ns:yang:ietf-yang-types");
- Date rev20100924 = QName.parseRevision("2010-09-24");
- Date rev20130516 = QName.parseRevision("2013-05-16");
- Date rev20130715 = QName.parseRevision("2013-07-15");
+ final Date rev20100924 = QName.parseRevision("2010-09-24");
+ final Date rev20130516 = QName.parseRevision("2013-05-16");
+ final Date rev20130715 = QName.parseRevision("2013-07-15");
final QNameModule yangTypes_20100924 = QNameModule.create(yangTypesNS, rev20100924);
final QNameModule yangTypes_20130516 = QNameModule.create(yangTypesNS, rev20130516);
final QName dateTimeTypeDef_20130516 = QName.create(yangTypes_20130516, "date-and-time");
final QName dateTimeTypeDef_20130715 = QName.create(yangTypes_20130715, "date-and-time");
- Module yangTypesModule_20100924 = context.findModuleByName("ietf-yang-types", rev20100924);
- Module yangTypesModule_20130516 = context.findModuleByName("ietf-yang-types", rev20130516);
- Module yangTypesModule_20130715 = context.findModuleByName("ietf-yang-types", rev20130715);
-
- assertNotNull(yangTypesModule_20100924);
- assertNotNull(yangTypesModule_20130516);
- assertNotNull(yangTypesModule_20130715);
-
+ Module yangTypesModule_20100924 = context.findModule("ietf-yang-types", rev20100924).get();
+ Module yangTypesModule_20130516 = context.findModule("ietf-yang-types", rev20130516).get();
+ Module yangTypesModule_20130715 = context.findModule("ietf-yang-types", rev20130715).get();
assertTrue(findTypeDef(yangTypesModule_20100924, dateTimeTypeDef_20100924));
assertTrue(findTypeDef(yangTypesModule_20130516, dateTimeTypeDef_20130516));
assertTrue(findTypeDef(yangTypesModule_20130715, dateTimeTypeDef_20130715));
final QNameModule interfacesNS_20121115 = QNameModule.create(interfacesNS, rev20121115);
QName lastChange = QName.create(interfacesNS_20121115, "last-change");
- Module interfacesModule_20121115 = context.findModuleByName("ietf-interfaces", rev20121115);
- assertNotNull(interfacesModule_20121115);
-
- DataSchemaNode leafLastChange = interfacesModule_20121115
- .getDataChildByName(lastChange);
+ Module interfacesModule_20121115 = context.findModule("ietf-interfaces", rev20121115).get();
+ DataSchemaNode leafLastChange = interfacesModule_20121115.getDataChildByName(lastChange);
assertNotNull(leafLastChange);
assertTrue(leafLastChange instanceof LeafSchemaNode);
private static void checkNetconfMonitoringModuleSimpleTest(final SchemaContext context,
final Date rev20130715, final QName dateTimeTypeDef_20130715) {
URI monitoringNS = URI.create("urn:ietf:params:xml:ns:yang:ietf-netconf-monitoring");
- Date rev19700101 = QName.parseRevision("1970-01-01");
- final QNameModule monitoring_19700101 = QNameModule.create(monitoringNS, rev19700101);
+ final QNameModule monitoring_19700101 = QNameModule.create(monitoringNS, SimpleDateFormatUtil.DEFAULT_DATE_REV);
QName lockedTime = QName.create(monitoring_19700101, "locked-time");
- Module monitoringModule_19700101 = context.findModuleByName("ietf-netconf-monitoring", rev19700101);
- assertNotNull(monitoringModule_19700101);
-
+ Module monitoringModule_19700101 = context.findModule("ietf-netconf-monitoring",
+ SimpleDateFormatUtil.DEFAULT_DATE_REV).get();
DataSchemaNode leafLockedTime = monitoringModule_19700101.getDataChildByName(lockedTime);
assertNotNull(leafLockedTime);
final SchemaContext result = reactor.buildEffective();
assertNotNull(result);
- final Module testModule = result.findModuleByName("must-test", null);
+ final Module testModule = result.findModules("must-test").iterator().next();
assertNotNull(testModule);
final ContainerSchemaNode container = (ContainerSchemaNode) testModule.getDataChildByName(
final SchemaContext result = reactor.buildEffective();
assertNotNull(result);
- final Module testModule = result.findModuleByName("when-test", null);
+ final Module testModule = result.findModules("when-test").iterator().next();
assertNotNull(testModule);
final ContainerSchemaNode container = (ContainerSchemaNode) testModule.getDataChildByName(
final SchemaContext result = reactor.buildEffective();
assertNotNull(result);
- final Module testModule = result.findModuleByName("baz", null);
+ final Module testModule = result.findModules("baz").iterator().next();
assertNotNull(testModule);
final Set<NotificationDefinition> notifications = testModule.getNotifications();
import static org.junit.Assert.assertTrue;
import static org.opendaylight.yangtools.yang.stmt.StmtTestUtils.sourceForResource;
-import java.util.Date;
import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
final SchemaContext result = reactor.buildEffective();
assertNotNull(result);
- final Module testModule = result.findModuleByName("baz", null);
- assertNotNull(testModule);
-
+ final Module testModule = result.findModules("baz").iterator().next();
assertEquals(1, testModule.getRpcs().size());
final RpcDefinition rpc = testModule.getRpcs().iterator().next();
anyXml = (AnyXmlSchemaNode) output.getDataChildByName(QName.create(testModule.getQNameModule(), "data"));
assertNotNull(anyXml);
- final Module fooModule = result.findModuleByName("foo", QName.parseRevision("2016-09-23"));
- assertNotNull(fooModule);
-
+ final Module fooModule = result.findModule("foo", QName.parseRevision("2016-09-23")).get();
final Set<RpcDefinition> rpcs = fooModule.getRpcs();
assertEquals(2, rpcs.size());
final SchemaContext schemaContext = StmtTestUtils.parseYangSource("/rpc-stmt-test/bar.yang");
assertNotNull(schemaContext);
- final Date revision = QName.parseRevision("2016-11-25");
-
- final Module barModule = schemaContext.findModuleByName("bar", revision);
- assertNotNull(barModule);
-
+ final Module barModule = schemaContext.findModule("bar", QName.parseRevision("2016-11-25")).get();
final Set<RpcDefinition> rpcs = barModule.getRpcs();
assertEquals(1, rpcs.size());
return parseYinSources(statementParserMode, sources);
}
- public static SchemaContext parseYinSources(final StatementParserMode statementParserMode, final StatementStreamSource... sources)
+ public static SchemaContext parseYinSources(final StatementParserMode statementParserMode,
+ final StatementStreamSource... sources)
throws ReactorException {
- final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR.newBuild(statementParserMode);
+ final CrossSourceStatementReactor.BuildAction reactor = YangInferencePipeline.RFC6020_REACTOR
+ .newBuild(statementParserMode);
reactor.addSources(sources);
return reactor.buildEffective();
}
- public static Module findImportedModule(final SchemaContext context, final Module rootModule, final String importedModuleName) {
+ public static Module findImportedModule(final SchemaContext context, final Module rootModule,
+ final String importedModuleName) {
ModuleImport requestedModuleImport = null;
final Set<ModuleImport> rootImports = rootModule.getImports();
for (final ModuleImport moduleImport : rootImports) {
}
}
- final Module importedModule = context.findModuleByName(requestedModuleImport.getModuleName(),
- requestedModuleImport.getRevision());
- return importedModule;
+ return context.findModule(requestedModuleImport.getModuleName(), requestedModuleImport.getRevision())
+ .orElse(null);
}
- public static SchemaContext parseYangSources(final String yangFilesDirectoryPath, final String yangLibsDirectoryPath)
+ public static SchemaContext parseYangSources(final String yangFilesDirectoryPath,
+ final String yangLibsDirectoryPath)
throws URISyntaxException, ReactorException, IOException, YangSyntaxErrorException {
return parseYangSources(yangFilesDirectoryPath, yangLibsDirectoryPath, null);
}
import com.google.common.collect.ImmutableSet;
import java.net.URI;
-import java.text.ParseException;
import java.util.Date;
import java.util.List;
import java.util.Set;
-import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
-import org.opendaylight.yangtools.yang.common.SimpleDateFormatUtil;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
import org.opendaylight.yangtools.yang.model.api.Module;
private static final StatementStreamSource IETF_RESTCONF_MODULE = sourceForResource(
"/yang-data-extension-test/ietf-restconf.yang");
- private static Date revision;
- private static QNameModule fooModule;
- private static QName myYangDataA;
- private static QName myYangDataB;
-
- @BeforeClass
- public static void setup() throws ParseException {
- revision = SimpleDateFormatUtil.getRevisionFormat().parse("2017-06-01");
- fooModule = QNameModule.create(URI.create("foo"), revision);
- myYangDataA = QName.create(fooModule, "my-yang-data-a");
- myYangDataB = QName.create(fooModule, "my-yang-data-b");
- }
+ private static final Date REVISION = QName.parseRevision("2017-06-01");
+ private static final QNameModule FOO_QNAMEMODULE = QNameModule.create(URI.create("foo"), REVISION);
+ private static final QName MY_YANG_DATA_A = QName.create(FOO_QNAMEMODULE, "my-yang-data-a");
+ private static final QName MY_YANG_DATA_B = QName.create(FOO_QNAMEMODULE, "my-yang-data-b");
@Test
public void testYangData() throws Exception {
final Set<ExtensionDefinition> extensions = schemaContext.getExtensions();
assertEquals(1, extensions.size());
- final Module foo = schemaContext.findModuleByName("foo", revision);
- assertNotNull(foo);
-
+ final Module foo = schemaContext.findModule(FOO_QNAMEMODULE).get();
final List<UnknownSchemaNode> unknownSchemaNodes = foo.getUnknownSchemaNodes();
assertEquals(2, unknownSchemaNodes.size());
for (final UnknownSchemaNode unknownSchemaNode : unknownSchemaNodes) {
assertTrue(unknownSchemaNode instanceof YangDataSchemaNode);
final YangDataSchemaNode yangDataSchemaNode = (YangDataSchemaNode) unknownSchemaNode;
- if (myYangDataA.equals(yangDataSchemaNode.getQName())) {
+ if (MY_YANG_DATA_A.equals(yangDataSchemaNode.getQName())) {
myYangDataANode = yangDataSchemaNode;
- } else if (myYangDataB.equals(yangDataSchemaNode.getQName())) {
+ } else if (MY_YANG_DATA_B.equals(yangDataSchemaNode.getQName())) {
myYangDataBNode = yangDataSchemaNode;
}
}
final SchemaContext schemaContext = StmtTestUtils.parseYangSources(BAZ_MODULE, IETF_RESTCONF_MODULE);
assertNotNull(schemaContext);
- final Module baz = schemaContext.findModuleByName("baz", revision);
- assertNotNull(baz);
-
+ final Module baz = schemaContext.findModule("baz", REVISION).get();
final List<UnknownSchemaNode> unknownSchemaNodes = baz.getUnknownSchemaNodes();
assertEquals(1, unknownSchemaNodes.size());
final SchemaContext schemaContext = reactor.buildEffective();
assertNotNull(schemaContext);
- final Module foobar = schemaContext.findModuleByName("foobar", revision);
- assertNotNull(foobar);
-
+ final Module foobar = schemaContext.findModule("foobar", REVISION).get();
final List<UnknownSchemaNode> unknownSchemaNodes = foobar.getUnknownSchemaNodes();
assertEquals(1, unknownSchemaNodes.size());
final SchemaContext schemaContext = StmtTestUtils.parseYangSources(BAR_MODULE, IETF_RESTCONF_MODULE);
assertNotNull(schemaContext);
- final Module bar = schemaContext.findModuleByName("bar", revision);
- assertNotNull(bar);
+ final Module bar = schemaContext.findModule("bar", REVISION).get();
final ContainerSchemaNode cont = (ContainerSchemaNode) bar.getDataChildByName(
QName.create(bar.getQNameModule(), "cont"));
assertNotNull(cont);
final SchemaContext context = reactor.buildEffective();
- final Module module = context.findModuleByName("test1", QName.parseRevision("2013-06-18"));
- assertNotNull(module);
-
+ final Module module = context.findModule("test1", QName.parseRevision("2013-06-18")).get();
final LeafSchemaNode leaf = (LeafSchemaNode) module.getDataChildByName(QName.create(module.getQNameModule(),
"id"));
reactor.addSources(BAZ, FOO, BAR, SUBFOO, test2);
final SchemaContext context = reactor.buildEffective();
- final Module testModule = context.findModuleByName("test2", QName.parseRevision("2013-06-18"));
- assertNotNull(testModule);
-
- final Module contextModule = context.findModuleByNamespace(URI.create("urn:opendaylight.baz")).iterator()
- .next();
+ final Module testModule = context.findModule("test2", QName.parseRevision("2013-06-18")).get();
+ final Module contextModule = context.findModules(URI.create("urn:opendaylight.baz")).iterator().next();
assertNotNull(contextModule);
final Set<GroupingDefinition> groupings = contextModule.getGroupings();
assertEquals(1, groupings.size());
reactor.addSources(BAZ, FOO, BAR, SUBFOO, test2);
final SchemaContext context = reactor.buildEffective();
- final Module module = context.findModuleByName("test2", QName.parseRevision("2013-06-18"));
- assertNotNull(module);
+ final Module module = context.findModule("test2", QName.parseRevision("2013-06-18")).get();
final ContainerSchemaNode peer = (ContainerSchemaNode) module.getDataChildByName(QName.create(
module.getQNameModule(), "peer"));
final ContainerSchemaNode destination = (ContainerSchemaNode) peer.getDataChildByName(QName.create(
reactor.addSources(types, test3);
final SchemaContext context = reactor.buildEffective();
- final Module module = context.findModuleByName("test3", QName.parseRevision("2013-06-18"));
- assertNotNull(module);
-
+ final Module module = context.findModule("test3", QName.parseRevision("2013-06-18")).get();
final Set<IdentitySchemaNode> identities = module.getIdentities();
assertEquals(1, identities.size());
final SchemaContext context = reactor.buildEffective();
- final Module module = context.findModuleByName("test3", QName.parseRevision("2013-06-18"));
- assertNotNull(module);
-
+ final Module module = context.findModule("test3", QName.parseRevision("2013-06-18")).get();
final ContainerSchemaNode network = (ContainerSchemaNode) module.getDataChildByName(QName.create(
module.getQNameModule(), "network"));
final List<UnknownSchemaNode> unknownNodes = network.getUnknownSchemaNodes();
reactor.addSources(bar, deviationTest);
final SchemaContext context = reactor.buildEffective();
- final Module testModule = context.findModuleByName("deviation-test", QName.parseRevision("2013-02-27"));
- assertNotNull(testModule);
-
+ final Module testModule = context.findModule("deviation-test", QName.parseRevision("2013-02-27")).get();
final Set<Deviation> deviations = testModule.getDeviations();
assertEquals(1, deviations.size());
final Deviation dev = deviations.iterator().next();
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModuleByNamespace(new URI("foo")).iterator().next();
- Module semVer = context.findModuleByNamespace(new URI("http://openconfig.net/yang/openconfig-ext"))
- .iterator().next();
+ Module foo = context.findModules(new URI("foo")).iterator().next();
+ Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModuleByNamespace(new URI("foo")).iterator().next();
- Module semVer = context.findModuleByNamespace(new URI("http://openconfig.net/yang/openconfig-ext"))
- .iterator().next();
+ Module foo = context.findModules(new URI("foo")).iterator().next();
+ Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModuleByNamespace(new URI("foo")).iterator().next();
- Module semVer = context.findModuleByNamespace(new URI("http://openconfig.net/yang/openconfig-ext"))
- .iterator().next();
+ Module foo = context.findModules(new URI("foo")).iterator().next();
+ Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
private static void verifySchemaContextTest1(final SchemaContext context) {
assertNotNull(context);
- final Module foo = context.findModuleByNamespace(URI.create("foo")).iterator().next();
- final Module semVer = context.findModuleByNamespace(
- URI.create("http://openconfig.net/yang/openconfig-ext")).iterator().next();
+ final Module foo = context.findModules(URI.create("foo")).iterator().next();
+ final Module semVer = context.findModules(URI.create("http://openconfig.net/yang/openconfig-ext"))
+ .iterator().next();
// check module versions
assertEquals(SemVer.valueOf("1.3.95"), semVer.getSemanticVersion().get());
private static void verifySchemaContextTest2(final SchemaContext context) {
assertNotNull(context);
- final Module foo = context.findModuleByNamespace(URI.create("foo")).iterator().next();
- final Module semVer = context.findModuleByNamespace(URI.create(
- "http://openconfig.net/yang/openconfig-ext")).iterator().next();
+ final Module foo = context.findModules(URI.create("foo")).iterator().next();
+ final Module semVer = context.findModules(URI.create("http://openconfig.net/yang/openconfig-ext"))
+ .iterator().next();
// check module versions
assertEquals(SemVer.valueOf("2.5.50"), semVer.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModuleByNamespace(new URI("foo")).iterator().next();
- Module bar = context.findModuleByNamespace(new URI("bar")).iterator().next();
+ Module foo = context.findModules(new URI("foo")).iterator().next();
+ Module bar = context.findModules(new URI("bar")).iterator().next();
assertEquals(Optional.empty(), foo.getSemanticVersion());
assertEquals(Optional.empty(), bar.getSemanticVersion());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModuleByNamespace(new URI("foo")).iterator().next();
- Module bar = context.findModuleByNamespace(new URI("bar")).iterator().next();
+ Module foo = context.findModules(new URI("foo")).iterator().next();
+ Module bar = context.findModules(new URI("bar")).iterator().next();
assertEquals(Optional.empty(), foo.getSemanticVersion());
assertEquals(SemVer.valueOf("0.99.99"), bar.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModuleByNamespace(new URI("foo")).iterator().next();
- Module bar = context.findModuleByNamespace(new URI("bar")).iterator().next();
- Module semVer = context.findModuleByNamespace(new URI("http://openconfig.net/yang/openconfig-ext"))
- .iterator().next();
+ Module foo = context.findModules(new URI("foo")).iterator().next();
+ Module bar = context.findModules(new URI("bar")).iterator().next();
+ Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModuleByNamespace(new URI("foo")).iterator().next();
- Module semVer = context.findModuleByNamespace(new URI("http://openconfig.net/yang/openconfig-ext"))
- .iterator().next();
+ Module foo = context.findModules(new URI("foo")).iterator().next();
+ Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
Module bar = StmtTestUtils.findImportedModule(context, foo, "bar");
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module semVer = context.findModuleByNamespace(new URI("http://openconfig.net/yang/openconfig-ext"))
- .iterator().next();
+ Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
assertEquals(SemVer.valueOf("1.0.0"), semVer.getSemanticVersion().get());
}
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModuleByNamespace(new URI("foo")).iterator().next();
- Module semVer = context.findModuleByNamespace(new URI("http://openconfig.net/yang/openconfig-ext"))
- .iterator().next();
+ Module foo = context.findModules(new URI("foo")).iterator().next();
+ Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModuleByNamespace(new URI("foo")).iterator().next();
- Module semVer = context.findModuleByNamespace(new URI("http://openconfig.net/yang/openconfig-ext"))
- .iterator().next();
+ Module foo = context.findModules(new URI("foo")).iterator().next();
+ Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
}
}
- Module importedModule = context.findModuleByName(requestedModuleImport.getModuleName(),
- requestedModuleImport.getRevision());
- return importedModule;
+ return context.findModule(requestedModuleImport.getModuleName(), requestedModuleImport.getRevision()).get();
}
}
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModuleByNamespace(new URI("foo")).iterator().next();
- Module bar = context.findModuleByNamespace(new URI("bar")).iterator().next();
- Module semVer = context.findModuleByNamespace(new URI("http://openconfig.net/yang/openconfig-ext"))
- .iterator().next();
+ Module foo = context.findModules(new URI("foo")).iterator().next();
+ Module bar = context.findModules(new URI("bar")).iterator().next();
+ Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModuleByNamespace(new URI("foo")).iterator().next();
- Module bar = context.findModuleByNamespace(new URI("bar")).iterator().next();
- Module semVer = context.findModuleByNamespace(new URI("http://openconfig.net/yang/openconfig-ext"))
- .iterator().next();
+ Module foo = context.findModules(new URI("foo")).iterator().next();
+ Module bar = context.findModules(new URI("bar")).iterator().next();
+ Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModuleByNamespace(new URI("foo")).iterator().next();
- Module bar = context.findModuleByNamespace(new URI("bar")).iterator().next();
- Module semVer = context.findModuleByNamespace(new URI("http://openconfig.net/yang/openconfig-ext"))
- .iterator().next();
+ Module foo = context.findModules(new URI("foo")).iterator().next();
+ Module bar = context.findModules(new URI("bar")).iterator().next();
+ Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModuleByNamespace(new URI("foo")).iterator().next();
- Module bar = context.findModuleByNamespace(new URI("bar")).iterator().next();
- Module semVer = context.findModuleByNamespace(new URI("http://openconfig.net/yang/openconfig-ext"))
- .iterator().next();
+ Module foo = context.findModules(new URI("foo")).iterator().next();
+ Module bar = context.findModules(new URI("bar")).iterator().next();
+ Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModuleByNamespace(new URI("foo")).iterator().next();
- Module bar = context.findModuleByNamespace(new URI("bar")).iterator().next();
- Module semVer = context.findModuleByNamespace(new URI("http://openconfig.net/yang/openconfig-ext"))
- .iterator().next();
+ Module foo = context.findModules(new URI("foo")).iterator().next();
+ Module bar = context.findModules(new URI("bar")).iterator().next();
+ Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModuleByNamespace(new URI("foo")).iterator().next();
- Module semVer = context.findModuleByNamespace(new URI("http://openconfig.net/yang/openconfig-ext"))
- .iterator().next();
+ Module foo = context.findModules(new URI("foo")).iterator().next();
+ Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModuleByNamespace(new URI("foo")).iterator().next();
- Module semVer = context.findModuleByNamespace(new URI("http://openconfig.net/yang/openconfig-ext"))
- .iterator().next();
+ Module foo = context.findModules(new URI("foo")).iterator().next();
+ Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModuleByNamespace(new URI("foo")).iterator().next();
- Module semVer = context.findModuleByNamespace(new URI("http://openconfig.net/yang/openconfig-ext"))
- .iterator().next();
+ Module foo = context.findModules(new URI("foo")).iterator().next();
+ Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
@Test
public void basicImportErrTest1() throws Exception {
try {
- StmtTestUtils.parseYangSources("/openconfig-version/basic-import-invalid-1", StatementParserMode.SEMVER_MODE);
+ StmtTestUtils.parseYangSources("/openconfig-version/basic-import-invalid-1",
+ StatementParserMode.SEMVER_MODE);
fail("Test should fail due to invalid openconfig version");
} catch (ReactorException e) {
assertTrue(e.getCause().getCause().getMessage()
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModuleByNamespace(new URI("foo")).iterator().next();
- Module semVer = context.findModuleByNamespace(new URI("http://openconfig.net/yang/openconfig-ext"))
- .iterator().next();
+ Module foo = context.findModules(new URI("foo")).iterator().next();
+ Module semVer = context.findModules(new URI("http://openconfig.net/yang/openconfig-ext")).iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("2016.1.1"), foo.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModuleByNamespace(URI.create("foo")).iterator().next();
- Module bar = context.findModuleByNamespace(URI.create("bar")).iterator().next();
- Module semVer = context.findModuleByNamespace(URI.create("http://openconfig.net/yang/openconfig-ext"))
- .iterator().next();
+ Module foo = context.findModules(URI.create("foo")).iterator().next();
+ Module bar = context.findModules(URI.create("bar")).iterator().next();
+ Module semVer = context.findModules(URI.create("http://openconfig.net/yang/openconfig-ext")).iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
StatementParserMode.SEMVER_MODE);
assertNotNull(context);
- Module foo = context.findModuleByNamespace(URI.create("foo")).iterator().next();
- Module semVer = context.findModuleByNamespace(URI.create("http://openconfig.net/yang/openconfig-ext"))
- .iterator().next();
+ Module foo = context.findModules(URI.create("foo")).iterator().next();
+ Module semVer = context.findModules(URI.create("http://openconfig.net/yang/openconfig-ext")).iterator().next();
assertEquals(SemVer.valueOf("0.0.1"), semVer.getSemanticVersion().get());
assertEquals(SemVer.valueOf("0.1.1"), foo.getSemanticVersion().get());
import com.google.common.annotations.Beta;
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Verify;
-import java.util.Date;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
@Override
public ModuleIdentifier select(final ModuleIdentifier first, final ModuleIdentifier second) {
- final Date firstRev = Verify.verifyNotNull(first.getRevision());
- final Date secondRev = Verify.verifyNotNull(second.getRevision());
- return firstRev.compareTo(secondRev) >= 0 ? first : second;
+ return ModuleIdentifier.compareRevisions(first.getRevision(), second.getRevision()) >= 0 ? first : second;
}
@Override
Code Review / yangtools.git / commitdiff