X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-parser-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fparser%2Futil%2FModuleDependencySort.java;h=c34a8f421824dc494aa3b08e330fcc134618960a;hb=42abb28b99a02f9580f4676ce5c315628e5bcd24;hp=8f22718eb865f3dd5acbebdd7bb07a727fcb0524;hpb=0e1cd560a2961bfb5ebdb0a887460b6794621cfa;p=yangtools.git diff --git a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/util/ModuleDependencySort.java b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/util/ModuleDependencySort.java index 8f22718eb8..c34a8f4218 100644 --- a/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/util/ModuleDependencySort.java +++ b/yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/util/ModuleDependencySort.java @@ -7,15 +7,22 @@ */ package org.opendaylight.yangtools.yang.parser.util; -import java.text.SimpleDateFormat; -import java.util.ArrayList; -import java.util.Arrays; +import static java.util.Arrays.asList; +import com.google.common.annotations.VisibleForTesting; +import com.google.common.base.Function; +import com.google.common.collect.Lists; +import com.google.common.collect.Maps; +import com.google.common.collect.Sets; +import java.net.URI; +import java.util.Collection; import java.util.Collections; import java.util.Date; +import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.Set; - +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; @@ -25,12 +32,6 @@ import org.opendaylight.yangtools.yang.parser.util.TopologicalSort.NodeImpl; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import com.google.common.annotations.VisibleForTesting; -import com.google.common.base.Function; -import com.google.common.collect.Lists; -import com.google.common.collect.Maps; -import com.google.common.collect.Sets; - /** * Creates a module dependency graph from provided {@link ModuleBuilder}s and * provides a {@link #sort(ModuleBuilder...)} method. It is topological sort and @@ -39,8 +40,18 @@ import com.google.common.collect.Sets; */ public final class ModuleDependencySort { - private static final Date DEFAULT_REVISION = new Date(0); + private static final Date DEFAULT_REVISION = SimpleDateFormatUtil.DEFAULT_DATE_REV; private static final Logger LOGGER = LoggerFactory.getLogger(ModuleDependencySort.class); + private static final Function TOPOLOGY_FUNCTION = new Function() { + @Override + public Module apply(final TopologicalSort.Node input) { + if (input == null) { + return null; + } + ModuleOrModuleBuilder moduleOrModuleBuilder = ((ModuleNodeImpl) input).getReference(); + return moduleOrModuleBuilder.getModule(); + } + }; /** * It is not desirable to instance this class @@ -48,37 +59,60 @@ public final class ModuleDependencySort { private ModuleDependencySort() { } + + /** + * Extracts {@link ModuleBuilder} from a {@link ModuleNodeImpl}. + */ + private static final Function NODE_TO_MODULEBUILDER = new Function() { + @Override + public ModuleBuilder apply(final TopologicalSort.Node input) { + // Cast to ModuleBuilder from Node and return + if (input == null) { + return null; + } + ModuleOrModuleBuilder moduleOrModuleBuilder = ((ModuleNodeImpl) input).getReference(); + return moduleOrModuleBuilder.getModuleBuilder(); + } + }; + /** * Topological sort of module builder dependency graph. * + * @param builders builders of Module object * @return Sorted list of Module builders. Modules can be further processed * in returned order. + * @deprecated Pre-Beryllium implementation, scheduled for removal. */ - public static List sort(ModuleBuilder... builders) { - List sorted = sortInternal(Arrays.asList(builders)); - // Cast to ModuleBuilder from Node and return - return Lists.transform(sorted, new Function() { + @Deprecated + public static List sort(final ModuleBuilder... builders) { + return sort(asList(builders)); + } - @Override - public ModuleBuilder apply(Node input) { - return (ModuleBuilder) ((ModuleNodeImpl) input).getReference(); - } - }); + /** + * @deprecated Pre-Beryllium implementation, scheduled for removal. + */ + @Deprecated + public static List sort(final Collection builders) { + List sorted = sortInternal(ModuleOrModuleBuilder.fromAll( + Collections.emptySet(),builders)); + return Lists.transform(sorted, NODE_TO_MODULEBUILDER); } - public static List sortWithContext(SchemaContext context, ModuleBuilder... builders) { - List modules = new ArrayList(); - Collections.addAll(modules, builders); - modules.addAll(context.getModules()); + public static List sortWithContext(final SchemaContext context, final ModuleBuilder... builders) { + List all = ModuleOrModuleBuilder.fromAll(context.getModules(), asList(builders)); - List sorted = sortInternal(modules); + List sorted = sortInternal(all); // Cast to ModuleBuilder from Node if possible and return - return Lists.transform(sorted, new Function() { + return Lists.transform(sorted, new Function() { @Override - public ModuleBuilder apply(Node input) { - if (((ModuleNodeImpl) input).getReference() instanceof ModuleBuilder) { - return (ModuleBuilder) ((ModuleNodeImpl) input).getReference(); + public ModuleBuilder apply(final TopologicalSort.Node input) { + if (input == null) { + return null; + } + ModuleOrModuleBuilder moduleOrModuleBuilder = ((ModuleNodeImpl) input).getReference(); + if (moduleOrModuleBuilder.isModuleBuilder()) { + return moduleOrModuleBuilder.getModuleBuilder(); } else { return null; } @@ -89,25 +123,21 @@ public final class ModuleDependencySort { /** * Topological sort of module dependency graph. * + * @param modules YANG modules * @return Sorted list of Modules. Modules can be further processed in * returned order. */ - public static List sort(Module... modules) { - List sorted = sortInternal(Arrays.asList(modules)); + public static List sort(final Module... modules) { + List sorted = sortInternal(ModuleOrModuleBuilder.fromAll(asList(modules), + Collections.emptyList())); // Cast to Module from Node and return - return Lists.transform(sorted, new Function() { - - @Override - public Module apply(Node input) { - return (Module) ((ModuleNodeImpl) input).getReference(); - } - }); + return Lists.transform(sorted, TOPOLOGY_FUNCTION); } - private static List sortInternal(List modules) { + private static List sortInternal(final Iterable modules) { Map> moduleGraph = createModuleGraph(modules); - Set nodes = Sets.newHashSet(); + Set nodes = Sets.newHashSet(); for (Map map : moduleGraph.values()) { for (ModuleNodeImpl node : map.values()) { nodes.add(node); @@ -118,7 +148,7 @@ public final class ModuleDependencySort { } @VisibleForTesting - static Map> createModuleGraph(List builders) { + static Map> createModuleGraph(final Iterable builders) { Map> moduleGraph = Maps.newHashMap(); processModules(moduleGraph, builders); @@ -130,26 +160,54 @@ public final class ModuleDependencySort { /** * Extract module:revision from module builders */ - private static void processDependencies(Map> moduleGraph, List builders) { - + private static void processDependencies(final Map> moduleGraph, + final Iterable mmbs) { + Map allNS = new HashMap<>(); // Create edges in graph - for (Object mb : builders) { + for (ModuleOrModuleBuilder mmb : mmbs) { Map imported = Maps.newHashMap(); - String fromName = null; - Date fromRevision = null; - Set imports = null; - - if (mb instanceof Module) { - fromName = ((Module) mb).getName(); - fromRevision = ((Module) mb).getRevision(); - imports = ((Module) mb).getImports(); - } else if (mb instanceof ModuleBuilder) { - fromName = ((ModuleBuilder) mb).getName(); - fromRevision = ((ModuleBuilder) mb).getRevision(); - imports = ((ModuleBuilder) mb).getModuleImports(); + String fromName; + Date fromRevision; + Collection imports; + URI ns; + + if (mmb.isModule()) { + Module module = mmb.getModule(); + fromName = module.getName(); + fromRevision = module.getRevision(); + imports = module.getImports(); + ns = module.getNamespace(); + } else { + ModuleBuilder moduleBuilder = mmb.getModuleBuilder(); + fromName = moduleBuilder.getName(); + fromRevision = moduleBuilder.getRevision(); + imports = moduleBuilder.getImports().values(); + ns = moduleBuilder.getNamespace(); + } + + // check for existence of module with same namespace + if (allNS.containsKey(ns)) { + ModuleOrModuleBuilder mod = allNS.get(ns); + String name = null; + Date revision = null; + if (mod.isModule()) { + name = mod.getModule().getName(); + revision = mod.getModule().getRevision(); + } else if (mod.isModuleBuilder()) { + name = mod.getModuleBuilder().getName(); + revision = mod.getModuleBuilder().getRevision(); + } + if (!(fromName.equals(name))) { + LOGGER.warn( + "Error while sorting module [{}, {}]: module with same namespace ({}) already loaded: [{}, {}]", + fromName, fromRevision, ns, name, revision); + } + } else { + allNS.put(ns, mmb); } + // no need to check if other Type of object, check is performed in // process modules @@ -185,8 +243,8 @@ public final class ModuleDependencySort { /** * Get imported module by its name and revision from moduleGraph */ - private static ModuleNodeImpl getModuleByNameAndRevision(Map> moduleGraph, - String fromName, Date fromRevision, String toName, Date toRevision) { + private static ModuleNodeImpl getModuleByNameAndRevision(final Map> moduleGraph, + final String fromName, final Date fromRevision, final String toName, final Date toRevision) { ModuleNodeImpl to = null; if (moduleGraph.get(toName) == null || !moduleGraph.get(toName).containsKey(toRevision)) { @@ -195,7 +253,7 @@ public final class ModuleDependencySort { if (moduleGraph.get(toName) != null && !moduleGraph.get(toName).isEmpty() && toRevision.equals(DEFAULT_REVISION)) { to = moduleGraph.get(toName).values().iterator().next(); - LOGGER.debug(String + LOGGER.trace(String .format("Import:%s:%s by module:%s:%s does not specify revision, using:%s:%s for module dependency sort", toName, formatRevDate(toRevision), fromName, formatRevDate(fromRevision), to.getName(), formatRevDate(to.getRevision()))); @@ -212,7 +270,7 @@ public final class ModuleDependencySort { return to; } - private static void ex(String message) { + private static void ex(final String message) { throw new YangValidationException(message); } @@ -220,24 +278,21 @@ public final class ModuleDependencySort { * Extract dependencies from module builders or modules to fill dependency * graph */ - private static void processModules(Map> moduleGraph, List builders) { + private static void processModules(final Map> moduleGraph, + final Iterable builders) { // Process nodes - for (Object mb : builders) { + for (ModuleOrModuleBuilder momb : builders) { - String name = null; - Date rev = null; + String name; + Date rev; - if (mb instanceof Module) { - name = ((Module) mb).getName(); - rev = ((Module) mb).getRevision(); - } else if (mb instanceof ModuleBuilder) { - name = ((ModuleBuilder) mb).getName(); - rev = ((ModuleBuilder) mb).getRevision(); + if (momb.isModule()) { + name = momb.getModule().getName(); + rev = momb.getModule().getRevision(); } else { - throw new IllegalStateException(String.format( - "Unexpected type of node for sort, expected only:%s, %s, got:%s", Module.class, - ModuleBuilder.class, mb.getClass())); + name = momb.getModuleBuilder().getName(); + rev = momb.getModuleBuilder().getRevision(); } if (rev == null) { @@ -252,21 +307,21 @@ public final class ModuleDependencySort { ex(String.format("Module:%s with revision:%s declared twice", name, formatRevDate(rev))); } - moduleGraph.get(name).put(rev, new ModuleNodeImpl(name, rev, mb)); + moduleGraph.get(name).put(rev, new ModuleNodeImpl(name, rev, momb)); } } - private static String formatRevDate(Date rev) { - return rev.equals(DEFAULT_REVISION) ? "default" : new SimpleDateFormat("yyyy-MM-dd").format(rev); + private static String formatRevDate(final Date rev) { + return rev.equals(DEFAULT_REVISION) ? "default" : SimpleDateFormatUtil.getRevisionFormat().format(rev); } @VisibleForTesting static class ModuleNodeImpl extends NodeImpl { private final String name; private final Date revision; - private final Object originalObject; + private final ModuleOrModuleBuilder originalObject; - public ModuleNodeImpl(String name, Date revision, Object builder) { + public ModuleNodeImpl(final String name, final Date revision, final ModuleOrModuleBuilder builder) { this.name = name; this.revision = revision; this.originalObject = builder; @@ -284,13 +339,13 @@ public final class ModuleDependencySort { public int hashCode() { final int prime = 31; int result = 1; - result = prime * result + ((name == null) ? 0 : name.hashCode()); - result = prime * result + ((revision == null) ? 0 : revision.hashCode()); + result = prime * result + Objects.hashCode(name); + result = prime * result + Objects.hashCode(revision); return result; } @Override - public boolean equals(Object obj) { + public boolean equals(final Object obj) { if (this == obj) { return true; } @@ -323,7 +378,7 @@ public final class ModuleDependencySort { return "Module [name=" + name + ", revision=" + formatRevDate(revision) + "]"; } - public Object getReference() { + public ModuleOrModuleBuilder getReference() { return originalObject; }