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=4c4b64a37cf1eeeeed0d0625a0e4c32ed58285a3;hpb=0154c433eb95540a81ef9630a05767791015a835;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 4c4b64a37c..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,18 +7,22 @@ */ package org.opendaylight.yangtools.yang.parser.util; +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.text.SimpleDateFormat; -import java.util.ArrayList; -import java.util.Arrays; 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; @@ -28,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 @@ -42,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 @@ -51,43 +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() { - - @Override - public ModuleBuilder apply(Node input) { - return (ModuleBuilder) ((ModuleNodeImpl) input).getReference(); - } - }); + @Deprecated + public static List sort(final ModuleBuilder... builders) { + return sort(asList(builders)); } - public static List sort(Collection builders) { - ModuleBuilder[] array = new ModuleBuilder[builders.size()]; - builders.toArray(array); - return sort(array); + /** + * @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; } @@ -98,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); @@ -127,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); @@ -139,41 +160,44 @@ public final class ModuleDependencySort { /** * Extract module:revision from module builders */ - private static void processDependencies(Map> moduleGraph, List builders) { - Map allNS = new HashMap<>(); + 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; - URI ns = null; - - if (mb instanceof Module) { - fromName = ((Module) mb).getName(); - fromRevision = ((Module) mb).getRevision(); - imports = ((Module) mb).getImports(); - ns = ((Module)mb).getNamespace(); - } else if (mb instanceof ModuleBuilder) { - fromName = ((ModuleBuilder) mb).getName(); - fromRevision = ((ModuleBuilder) mb).getRevision(); - imports = ((ModuleBuilder) mb).getModuleImports(); - ns = ((ModuleBuilder)mb).getNamespace(); + 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)) { - Object mod = allNS.get(ns); + ModuleOrModuleBuilder mod = allNS.get(ns); String name = null; Date revision = null; - if (mod instanceof Module) { - name = ((Module) mod).getName(); - revision = ((Module) mod).getRevision(); - } else if (mod instanceof ModuleBuilder) { - name = ((ModuleBuilder) mod).getName(); - revision = ((ModuleBuilder) mod).getRevision(); + 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( @@ -181,7 +205,7 @@ public final class ModuleDependencySort { fromName, fromRevision, ns, name, revision); } } else { - allNS.put(ns, mb); + allNS.put(ns, mmb); } // no need to check if other Type of object, check is performed in @@ -219,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)) { @@ -229,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()))); @@ -246,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); } @@ -254,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) { @@ -286,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; @@ -318,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; } @@ -357,7 +378,7 @@ public final class ModuleDependencySort { return "Module [name=" + name + ", revision=" + formatRevDate(revision) + "]"; } - public Object getReference() { + public ModuleOrModuleBuilder getReference() { return originalObject; }