X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fsal%2Fyang-prototype%2Fcode-generator%2Fyang-model-parser-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fyang%2Fparser%2Futil%2FModuleDependencySort.java;h=8cf9cea0cf65490b087b522771a563a10ed8afb5;hb=refs%2Fchanges%2F57%2F357%2F3;hp=75b600902db3e0656440ddce37b82f8151cb2a66;hpb=a640c5c549376e5d72038e033d49ef6f0df96c92;p=controller.git diff --git a/opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/yang/parser/util/ModuleDependencySort.java b/opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/yang/parser/util/ModuleDependencySort.java index 75b600902d..8cf9cea0cf 100644 --- a/opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/yang/parser/util/ModuleDependencySort.java +++ b/opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/yang/parser/util/ModuleDependencySort.java @@ -7,11 +7,13 @@ */ package org.opendaylight.controller.yang.parser.util; +import java.util.Arrays; import java.util.Date; import java.util.List; import java.util.Map; import java.util.Set; +import org.opendaylight.controller.yang.model.api.Module; import org.opendaylight.controller.yang.model.api.ModuleImport; import org.opendaylight.controller.yang.parser.builder.impl.ModuleBuilder; import org.opendaylight.controller.yang.parser.impl.YangParserListenerImpl; @@ -38,32 +40,45 @@ public final class ModuleDependencySort { private static final Logger logger = LoggerFactory .getLogger(ModuleDependencySort.class); - private final Map> moduleGraph; - /** + * Topological sort of module builder dependency graph. * - * @param builders - * Source for module dependency graph. - * @throws YangValidationException - * if 1. there are module:revision duplicates 2. there is - * imported not existing module 3. module is imported twice + * @return Sorted list of Module builders. Modules can be further processed + * in returned order. */ - public ModuleDependencySort(ModuleBuilder... builders) { - this.moduleGraph = createModuleGraph(builders); - } - - @VisibleForTesting - Map> getModuleGraph() { - return moduleGraph; + 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(); + } + }); } /** * Topological sort of module dependency graph. * - * @return Sorted list of modules. Modules can be further processed in + * @return Sorted list of Modules. Modules can be further processed in * returned order. */ - public List sort() { + public static List sort(Module... modules) { + List sorted = sortInternal(Arrays.asList(modules)); + // Cast to Module from Node and return + return Lists.transform(sorted, new Function() { + + @Override + public Module apply(Node input) { + return (Module) ((ModuleNodeImpl) input).getReference(); + } + }); + } + + private static List sortInternal(List modules) { + Map> moduleGraph = createModuleGraph(modules); + Set nodes = Sets.newHashSet(); for (Map map : moduleGraph.values()) { for (ModuleNodeImpl node : map.values()) { @@ -71,19 +86,12 @@ public final class ModuleDependencySort { } } - // Cast to ModuleNode from Node - return Lists.transform(TopologicalSort.sort(nodes), - new Function() { - - @Override - public ModuleSimple apply(Node input) { - return (ModuleSimple) input; - } - }); + return TopologicalSort.sort(nodes); } - private Map> createModuleGraph( - ModuleBuilder... builders) { + @VisibleForTesting + static Map> createModuleGraph( + List builders) { Map> moduleGraph = Maps.newHashMap(); processModules(moduleGraph, builders); @@ -95,17 +103,33 @@ public final class ModuleDependencySort { /** * Extract module:revision from module builders */ - private void processDependencies( - Map> moduleGraph, - ModuleBuilder... builders) { + private static void processDependencies( + Map> moduleGraph, List builders) { Map imported = Maps.newHashMap(); // Create edges in graph - for (ModuleBuilder mb : builders) { - String fromName = mb.getName(); - Date fromRevision = mb.getRevision() == null ? DEFAULT_REVISION - : mb.getRevision(); - for (ModuleImport imprt : mb.getModuleImports()) { + for (Object mb : builders) { + + 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(); + } + // no need to check if other Type of object, check is performed in + // process modules + + if (fromRevision == null) + fromRevision = DEFAULT_REVISION; + + for (ModuleImport imprt : imports) { String toName = imprt.getModuleName(); Date toRevision = imprt.getRevision() == null ? DEFAULT_REVISION : imprt.getRevision(); @@ -137,7 +161,7 @@ public final class ModuleDependencySort { /** * Get imported module by its name and revision from moduleGraph */ - private ModuleNodeImpl getModuleByNameAndRevision( + private static ModuleNodeImpl getModuleByNameAndRevision( Map> moduleGraph, String fromName, Date fromRevision, String toName, Date toRevision) { ModuleNodeImpl to = null; @@ -165,22 +189,37 @@ public final class ModuleDependencySort { return to; } - private void ex(String message) { + private static void ex(String message) { throw new YangValidationException(message); } /** - * Extract dependencies from module builders to fill dependency graph + * Extract dependencies from module builders or modules to fill dependency + * graph */ - private void processModules( - Map> moduleGraph, - ModuleBuilder... builders) { + private static void processModules( + Map> moduleGraph, List builders) { // Process nodes - for (ModuleBuilder mb : builders) { - String name = mb.getName(); + for (Object mb : builders) { + + String name = null; + Date rev = null; + + 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(); + } else { + throw new IllegalStateException( + String.format( + "Unexpected type of node for sort, expected only:%s, %s, got:%s", + Module.class, ModuleBuilder.class, + mb.getClass())); + } - Date rev = mb.getRevision(); if (rev == null) rev = DEFAULT_REVISION; @@ -191,7 +230,7 @@ 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)); + moduleGraph.get(name).put(rev, new ModuleNodeImpl(name, rev, mb)); } } @@ -200,30 +239,22 @@ public final class ModuleDependencySort { : YangParserListenerImpl.simpleDateFormat.format(rev); } - /** - * Simple representation of module. Contains name and revision. - */ - public interface ModuleSimple { - String getName(); - - Date getRevision(); - } - - static class ModuleNodeImpl extends NodeImpl implements ModuleSimple { + @VisibleForTesting + static class ModuleNodeImpl extends NodeImpl { private final String name; private final Date revision; + private final Object originalObject; - public ModuleNodeImpl(String name, Date revision) { + public ModuleNodeImpl(String name, Date revision, Object builder) { this.name = name; this.revision = revision; + this.originalObject = builder; } - @Override public String getName() { return name; } - @Override public Date getRevision() { return revision; } @@ -266,6 +297,10 @@ public final class ModuleDependencySort { + formatRevDate(revision) + "]"; } + public Object getReference() { + return originalObject; + } + } }