X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-model-api%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fmodel%2Fapi%2FSchemaContext.java;h=2147d9bda5b8b9eae1570e0cc9b7078f7fc7038a;hb=f2c2d685a6acdf303c9d187d8e16f5bd20b1af20;hp=7ced70c351704157e7375633ff1314d4a92b759a;hpb=540af616add97f45432509cfe49fd168afec06d4;p=yangtools.git diff --git a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/SchemaContext.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/SchemaContext.java index 7ced70c351..2147d9bda5 100644 --- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/SchemaContext.java +++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/SchemaContext.java @@ -7,13 +7,19 @@ */ package org.opendaylight.yangtools.yang.model.api; +import com.google.common.annotations.Beta; +import com.google.common.collect.ImmutableSet; import com.google.common.collect.Sets; import java.net.URI; -import java.util.Date; +import java.util.Collection; import java.util.Optional; import java.util.Set; -import javax.annotation.concurrent.Immutable; +import org.eclipse.jdt.annotation.NonNull; +import org.eclipse.jdt.annotation.Nullable; +import org.opendaylight.yangtools.concepts.Immutable; import org.opendaylight.yangtools.yang.common.QName; +import org.opendaylight.yangtools.yang.common.QNameModule; +import org.opendaylight.yangtools.yang.common.Revision; /** * The interface represents static view of compiled yang files, @@ -23,12 +29,13 @@ import org.opendaylight.yangtools.yang.common.QName; * Instances MUST be immutable and thus usage in multi threaded * environment is safe. */ -@Immutable -public interface SchemaContext extends ContainerSchemaNode { +// FIXME: 3.0.0: ContainerSchemaNode is far too broad. A combination of DataNodeContainer, NotificationNodeContainer +// and possibly DataSchemaNode would reflect SchemaContext traits better. +public interface SchemaContext extends ContainerSchemaNode, Immutable { /** * QName of NETCONF top-level data node. */ - QName NAME = QName.create(URI.create("urn:ietf:params:xml:ns:netconf:base:1.0"), null, "data").intern(); + @NonNull QName NAME = QName.create(URI.create("urn:ietf:params:xml:ns:netconf:base:1.0"), "data").intern(); /** * Returns data schema node instances which represents direct subnodes (like @@ -40,7 +47,9 @@ public interface SchemaContext extends ContainerSchemaNode { Set getDataDefinitions(); /** - * Returns modules which are part of the schema context. + * Returns modules which are part of the schema context. Returned set is required to have its iteration ordered + * by module revision, so that if modules are filtered by {@link Module#getName()} or {@link Module#getNamespace()}, + * modules having the same attribute are encountered newest revision first. * * @return set of the modules which belong to the schema context */ @@ -56,7 +65,7 @@ public interface SchemaContext extends ContainerSchemaNode { Set getOperations(); /** - * Returns extencion definition instances which are defined as the direct + * Returns extension definition instances which are defined as the direct * subelements in all YANG modules in the context. * * @return set of ExtensionDefinition instances which @@ -65,59 +74,142 @@ public interface SchemaContext extends ContainerSchemaNode { Set getExtensions(); /** - * Returns module instance (from the context) with concrete name and - * revision date. + * Returns the module matching specified {@link QNameModule}, if present. + * + * @param qnameModule requested QNameModule + * @return Module, if present. + * @throws NullPointerException if qnameModule is null + */ + Optional findModule(@NonNull QNameModule qnameModule); + + /** + * Returns module instance (from the context) with specified namespace and no revision. + * + * @param namespace module namespace + * @return module instance which has name and revision the same as are the values specified in parameters + * namespace and no revision. + */ + default Optional findModule(final @NonNull URI namespace) { + return findModule(QNameModule.create(namespace)); + } + + /** + * Returns module instance (from the context) with specified namespace and revision. + * + * @param namespace module namespace + * @param revision module revision, may be null + * @return module instance which has name and revision the same as are the values specified in parameters + * namespace and revision. + */ + default Optional findModule(final @NonNull URI namespace, final @Nullable Revision revision) { + return findModule(QNameModule.create(namespace, revision)); + } + + /** + * Returns module instance (from the context) with specified namespace and revision. + * + * @param namespace module namespace + * @param revision module revision, may be null + * @return module instance which has name and revision the same as are the values specified in parameters + * namespace and revision. + */ + default Optional findModule(final @NonNull URI namespace, final @NonNull Optional revision) { + return findModule(QNameModule.create(namespace, revision)); + } + + /** + * Returns module instance (from the context) with specified name and an optional revision. * * @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 name - * and revision. In other cases the null - * value is returned. + * @return module instance which has name and revision the same as are the values specified in parameters + * name and revision. + */ + default Optional findModule(final String name, final Optional revision) { + return findModules(name).stream().filter(module -> revision.equals(module.getRevision())).findAny(); + } + + /** + * Returns module instance (from the context) with specified name and revision. * + * @param name + * string with the module name + * @param revision + * 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 + * name and revision. */ - Module findModuleByName(String name, Date revision); + default Optional findModule(final String name, final @Nullable Revision revision) { + return findModule(name, Optional.ofNullable(revision)); + } - default Optional findAnyModuleByName(final String name) { - return Optional.ofNullable(findModuleByName(name, null)); + /** + * Returns module instance (from the context) with specified name and no revision. + * + * @param name string with the module name + * @return module instance which has name and revision the same as are the values specified in name + * and no revision. + * @throws NullPointerException if name is null + */ + default Optional findModule(final String name) { + return findModule(name, Optional.empty()); } /** - * Returns module instance (from the context) with concrete namespace. + * Returns module instances (from the context) with a concrete name. Returned Set is required to have its iteration + * order guarantee that the latest revision is encountered first. + * + * @param name + * string with the module name + * @return set of module instances with specified name. + */ + default Set findModules(final String name) { + return Sets.filter(getModules(), m -> name.equals(m.getName())); + } + + /** + * Returns module instance (from the context) with concrete namespace. Returned Set is required to have its + * iteration order guarantee that the latest revision is encountered first. * * @param namespace * URI instance with specified namespace * @return module instance which has namespace equal to the * namespace or null in other cases */ - default Set findModuleByNamespace(final URI namespace) { + default Set 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; + @Override + default Set getActions() { + return ImmutableSet.of(); } - /** - * Get all module and submodule identifiers. - */ - Set getAllModuleIdentifiers(); + @Override + default Optional getDescription() { + return Optional.empty(); + } + + @Override + default Optional getReference() { + return Optional.empty(); + } + + @Override + default Collection getMustConstraints() { + return ImmutableSet.of(); + } + + @Override + default Optional getWhenCondition() { + return Optional.empty(); + } + + @Beta + @Override + default Optional findDataTreeChild(final QName name) { + return findModule(name.getModule()).flatMap(mod -> mod.findDataTreeChild(name)); + } }