X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-model-util%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fmodel%2Futil%2FFilteringSchemaContextProxy.java;h=5462606533dea7751b2944169e9a85b3f59a8804;hb=f2c2d685a6acdf303c9d187d8e16f5bd20b1af20;hp=23d17132fbcb1c2b4fe3cc06f92419b0c3c3e417;hpb=f924c20549d1b3bd10e8359e2588e19560464933;p=yangtools.git diff --git a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/FilteringSchemaContextProxy.java b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/FilteringSchemaContextProxy.java index 23d17132fb..5462606533 100644 --- a/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/FilteringSchemaContextProxy.java +++ b/yang/yang-model-util/src/main/java/org/opendaylight/yangtools/yang/model/util/FilteringSchemaContextProxy.java @@ -3,17 +3,18 @@ * * This program and the accompanying materials are made available under the * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html.html + * and is available at http://www.eclipse.org/legal/epl-v10.html */ - package org.opendaylight.yangtools.yang.model.util; -import com.google.common.base.Function; +import static com.google.common.base.Preconditions.checkArgument; +import static java.util.Objects.requireNonNull; + import com.google.common.base.Preconditions; -import com.google.common.base.Predicate; import com.google.common.base.Strings; import com.google.common.collect.Collections2; import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; import com.google.common.collect.ImmutableSet.Builder; import com.google.common.collect.ImmutableSetMultimap; import com.google.common.collect.Lists; @@ -23,140 +24,126 @@ import com.google.common.collect.Multimaps; import com.google.common.collect.SetMultimap; import com.google.common.collect.TreeMultimap; import java.net.URI; +import java.util.ArrayList; import java.util.Collection; import java.util.Collections; -import java.util.Comparator; -import java.util.Date; import java.util.List; import java.util.Map; +import java.util.Optional; import java.util.Set; import java.util.TreeMap; -import javax.annotation.Nullable; -import javax.annotation.concurrent.Immutable; +import java.util.function.Function; +import org.opendaylight.yangtools.yang.common.QNameModule; +import org.opendaylight.yangtools.yang.common.Revision; import org.opendaylight.yangtools.yang.model.api.Module; -import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier; import org.opendaylight.yangtools.yang.model.api.ModuleImport; import org.opendaylight.yangtools.yang.model.api.SchemaContext; -@Immutable public final class FilteringSchemaContextProxy extends AbstractSchemaContext { + private final ImmutableMap moduleMap; //collection to be filled with filtered modules - private final Set filteredModules; + private final ImmutableSet filteredModules; //collections to be filled in with filtered data - private final Map identifiersToSources; - private final SetMultimap namespaceToModules; - private final SetMultimap nameToModules; + private final ImmutableSetMultimap namespaceToModules; + private final ImmutableSetMultimap nameToModules; /** - * Filters SchemaContext for yang modules + * Filters SchemaContext for yang modules. * * @param delegate original SchemaContext - * @param rootModules modules (yang schemas) to be available and all their dependencies (modules importing rootModule and whole chain of their imports) + * @param rootModules modules (yang schemas) to be available and all their dependencies (modules importing + * rootModule and whole chain of their imports) * @param additionalModuleIds (additional) modules (yang schemas) to be available and whole chain of their imports - * */ - public FilteringSchemaContextProxy(final SchemaContext delegate, final Collection rootModules, final Set additionalModuleIds) { - - Preconditions.checkArgument(rootModules!=null,"Base modules cannot be null."); - Preconditions.checkArgument(additionalModuleIds!=null,"Additional modules cannot be null."); + public FilteringSchemaContextProxy(final SchemaContext delegate, final Collection rootModules, + final Set additionalModuleIds) { + requireNonNull(rootModules, "Base modules cannot be null."); + requireNonNull(additionalModuleIds, "Additional modules cannot be null."); final Builder filteredModulesBuilder = new Builder<>(); - final SetMultimap nsMap = Multimaps.newSetMultimap(new TreeMap>(), MODULE_SET_SUPPLIER); - final SetMultimap nameMap = Multimaps.newSetMultimap(new TreeMap>(), MODULE_SET_SUPPLIER); - - ImmutableMap.Builder identifiersToSourcesBuilder = ImmutableMap.builder(); - - //preparing map to get all modules with one name but difference in revision - final TreeMultimap nameToModulesAll = getStringModuleTreeMultimap(); + // preparing map to get all modules with one name but difference in revision + final TreeMultimap nameToModulesAll = TreeMultimap.create(String::compareTo, + REVISION_COMPARATOR); nameToModulesAll.putAll(getStringModuleMap(delegate)); - //in case there is a particular dependancy to view filteredModules/yang models - //dependancy is checked for module name and imports + // in case there is a particular dependency to view filteredModules/YANG models dependency is checked + // for module name and imports processForRootModules(delegate, rootModules, filteredModulesBuilder); - //adding additional modules + // adding additional modules processForAdditionalModules(delegate, additionalModuleIds, filteredModulesBuilder); filteredModulesBuilder.addAll(getImportedModules( - Maps.uniqueIndex(delegate.getModules(), ModuleId.MODULE_TO_MODULE_ID), filteredModulesBuilder.build(), nameToModulesAll)); + Maps.uniqueIndex(delegate.getModules(), ModuleId.MODULE_TO_MODULE_ID::apply), + filteredModulesBuilder.build(), nameToModulesAll)); /** - * Instead of doing this on each invocation of getModules(), pre-compute - * it once and keep it around -- better than the set we got in. + * Instead of doing this on each invocation of getModules(), pre-compute it once and keep it around. */ - this.filteredModules = filteredModulesBuilder.build(); - - for (final Module module :filteredModules) { + final List sortedModules = new ArrayList<>(filteredModulesBuilder.build()); + sortedModules.sort(NAME_REVISION_COMPARATOR); + this.filteredModules = ImmutableSet.copyOf(sortedModules); + + final SetMultimap nsMap = Multimaps.newSetMultimap(new TreeMap<>(), + AbstractSchemaContext::createModuleSet); + final SetMultimap nameMap = Multimaps.newSetMultimap(new TreeMap<>(), + AbstractSchemaContext::createModuleSet); + final ImmutableMap.Builder moduleMapBuilder = ImmutableMap.builder(); + for (final Module module : filteredModules) { nameMap.put(module.getName(), module); nsMap.put(module.getNamespace(), module); - identifiersToSourcesBuilder.put(module, module.getSource()); + moduleMapBuilder.put(module.getQNameModule(), module); } namespaceToModules = ImmutableSetMultimap.copyOf(nsMap); nameToModules = ImmutableSetMultimap.copyOf(nameMap); - identifiersToSources = identifiersToSourcesBuilder.build(); - } - - private static TreeMultimap getStringModuleTreeMultimap() { - return TreeMultimap.create(new Comparator() { - @Override - public int compare(String o1, String o2) { - return o1.compareTo(o2); - } - }, REVISION_COMPARATOR); + moduleMap = moduleMapBuilder.build(); } - private void processForAdditionalModules(SchemaContext delegate, final Set additionalModuleIds, Builder filteredModulesBuilder) { - filteredModulesBuilder.addAll(Collections2.filter(delegate.getModules(), new Predicate() { - @Override - public boolean apply(@Nullable Module module) { - return selectAdditionalModules(module, additionalModuleIds); - } - })); + private static void processForAdditionalModules(final SchemaContext delegate, + final Set additionalModuleIds, final Builder filteredModulesBuilder) { + filteredModulesBuilder.addAll(Collections2.filter(delegate.getModules(), + module -> selectAdditionalModules(module, additionalModuleIds))); } - private void processForRootModules(SchemaContext delegate, final Collection rootModules, Builder filteredModulesBuilder) { - filteredModulesBuilder.addAll(Collections2.filter(delegate.getModules(), new Predicate() { - @Override - public boolean apply(@Nullable Module module) { - return checkModuleDependency(module, rootModules); - } - })); + private void processForRootModules(final SchemaContext delegate, final Collection rootModules, + final Builder filteredModulesBuilder) { + filteredModulesBuilder.addAll(Collections2.filter(delegate.getModules(), + module -> checkModuleDependency(module, rootModules))); } - private Multimap getStringModuleMap(SchemaContext delegate) { - return Multimaps.index(delegate.getModules(), new Function() { - @Override - public String apply(Module input) { - return input.getName(); - } - }); + private static Multimap getStringModuleMap(final SchemaContext delegate) { + return Multimaps.index(delegate.getModules(), Module::getName); } //dealing with imported module other than root and directly importing root - private static Collection getImportedModules(Map allModules, Set baseModules, TreeMultimap nameToModulesAll) { + private static Collection getImportedModules(final Map allModules, + final Set baseModules, final TreeMultimap nameToModulesAll) { List relatedModules = Lists.newLinkedList(); for (Module module : baseModules) { for (ModuleImport moduleImport : module.getImports()) { + Optional revisionDate = moduleImport.getRevision(); + if (!revisionDate.isPresent()) { + revisionDate = nameToModulesAll.get(moduleImport.getModuleName()).first().getRevision(); + } - Date revisionDate = moduleImport.getRevision() == null ? - nameToModulesAll.get(moduleImport.getModuleName()).first().getRevision() : moduleImport.getRevision(); - - ModuleId key = new ModuleId(moduleImport.getModuleName(),revisionDate); + ModuleId key = new ModuleId(moduleImport.getModuleName(), revisionDate); Module importedModule = allModules.get(key); - Preconditions.checkArgument(importedModule != null, "Invalid schema, cannot find imported module: %s from module: %s, %s, modules:%s", key, module.getQNameModule(), module.getName() ); + Preconditions.checkArgument(importedModule != null, + "Invalid schema, cannot find imported module: %s from module: %s, %s, modules:%s", key, + module.getQNameModule(), module.getName(), allModules); relatedModules.add(importedModule); //calling imports recursive - relatedModules.addAll(getImportedModules(allModules, Collections.singleton(importedModule), nameToModulesAll)); - + relatedModules.addAll(getImportedModules(allModules, Collections.singleton(importedModule), + nameToModulesAll)); } } @@ -164,14 +151,15 @@ public final class FilteringSchemaContextProxy extends AbstractSchemaContext { } @Override - protected Map getIdentifiersToSources() { - return identifiersToSources; - } - public Set getModules() { return filteredModules; } + @Override + protected Map getModuleMap() { + return moduleMap; + } + @Override protected SetMultimap getNamespaceToModules() { return namespaceToModules; @@ -182,35 +170,22 @@ public final class FilteringSchemaContextProxy extends AbstractSchemaContext { return nameToModules; } - private boolean selectAdditionalModules(Module module, Set additionalModules){ - - if(additionalModules.contains(new ModuleId(module.getName(), module.getRevision()))){ - - return true; - } - - return false; + private static boolean selectAdditionalModules(final Module module, final Set additionalModules) { + return additionalModules.contains(new ModuleId(module.getName(), module.getRevision())); } //check for any dependency regarding given string - private boolean checkModuleDependency(Module module, Collection rootModules) { - + private boolean checkModuleDependency(final Module module, final Collection rootModules) { for (ModuleId rootModule : rootModules) { - - if(rootModule.equals(new ModuleId(module.getName(), module.getRevision()))) { + if (rootModule.equals(new ModuleId(module.getName(), module.getRevision()))) { return true; } //handling/checking imports regarding root modules for (ModuleImport moduleImport : module.getImports()) { - - if(moduleImport.getModuleName().equals(rootModule.getName())) { - - if(moduleImport.getRevision() != null && !moduleImport.getRevision().equals(rootModule.getRev())) { - return false; - } - - return true; + if (moduleImport.getModuleName().equals(rootModule.getName())) { + return !moduleImport.getRevision().isPresent() + || moduleImport.getRevision().equals(rootModule.getRev()); } } @@ -230,38 +205,42 @@ public final class FilteringSchemaContextProxy extends AbstractSchemaContext { public static final class ModuleId { private final String name; - private final Date rev; + private final Revision rev; - public ModuleId(String name, Date rev) { - Preconditions.checkArgument(!Strings.isNullOrEmpty(name), "No module dependency name given. Nothing to do."); + public ModuleId(final String name, final Optional rev) { + checkArgument(!Strings.isNullOrEmpty(name), "No module dependency name given. Nothing to do."); this.name = name; - this.rev = Preconditions.checkNotNull(rev, "No revision date given. Nothing to do."); + checkArgument(rev.isPresent(), "No revision date given. Nothing to do."); + this.rev = rev.get(); } public String getName() { return name; } - public Date getRev() { - return rev; + public Optional getRev() { + return Optional.ofNullable(rev); } - public static final Function MODULE_TO_MODULE_ID = new Function() { - @Override - public ModuleId apply(Module input) { - return new ModuleId(input.getName(), input.getRevision()); - } - }; + public static final Function MODULE_TO_MODULE_ID = input -> new ModuleId(input.getName(), + input.getRevision()); @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - - ModuleId moduleId = (ModuleId) o; + public boolean equals(final Object obj) { + if (this == obj) { + return true; + } + if (!(obj instanceof ModuleId)) { + return false; + } - if (name != null ? !name.equals(moduleId.name) : moduleId.name != null) return false; - if (rev != null ? !rev.equals(moduleId.rev) : moduleId.rev != null) return false; + ModuleId moduleId = (ModuleId) obj; + if (name != null ? !name.equals(moduleId.name) : moduleId.name != null) { + return false; + } + if (rev != null ? !rev.equals(moduleId.rev) : moduleId.rev != null) { + return false; + } return true; } @@ -275,7 +254,6 @@ public final class FilteringSchemaContextProxy extends AbstractSchemaContext { @Override public String toString() { - return String.format("ModuleId{name='%s', rev=%s}",name,rev); } }