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=05dbd2e1b7f1d7f0b4ba454e94138a257e59e396;hb=4302f95307c27902956e838f52d06bf97e879639;hp=c66698f3dc28d849932e72e079cf9b642e3991c9;hpb=dea46b20bfec80fe9d84dd1768219b497d57cc15;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 c66698f3dc..05dbd2e1b7 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 @@ -1,23 +1,29 @@ /* - * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved. - * + * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved. * 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 */ 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.base.Optional; +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.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; @@ -27,12 +33,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 @@ -43,6 +43,16 @@ public final class ModuleDependencySort { private static final Date DEFAULT_REVISION = new Date(0); 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 @@ -50,37 +60,53 @@ 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. * * @return Sorted list of Module builders. Modules can be further processed * in returned order. */ - 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() { + public static List sort(final ModuleBuilder... builders) { + return sort(asList(builders)); + } - @Override - public ModuleBuilder apply(Node input) { - return (ModuleBuilder) ((ModuleNodeImpl) input).getReference(); - } - }); + 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; } @@ -94,22 +120,17 @@ public final class ModuleDependencySort { * @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); @@ -120,7 +141,7 @@ public final class ModuleDependencySort { } @VisibleForTesting - static Map> createModuleGraph(List builders) { + static Map> createModuleGraph(final Iterable builders) { Map> moduleGraph = Maps.newHashMap(); processModules(moduleGraph, builders); @@ -132,41 +153,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( @@ -174,7 +198,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 @@ -212,8 +236,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)) { @@ -222,7 +246,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()))); @@ -239,7 +263,7 @@ public final class ModuleDependencySort { return to; } - private static void ex(String message) { + private static void ex(final String message) { throw new YangValidationException(message); } @@ -247,24 +271,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) { @@ -279,21 +300,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; @@ -317,7 +338,7 @@ public final class ModuleDependencySort { } @Override - public boolean equals(Object obj) { + public boolean equals(final Object obj) { if (this == obj) { return true; } @@ -350,10 +371,47 @@ public final class ModuleDependencySort { return "Module [name=" + name + ", revision=" + formatRevDate(revision) + "]"; } - public Object getReference() { + public ModuleOrModuleBuilder getReference() { return originalObject; } } } +class ModuleOrModuleBuilder { + private final Optional maybeModule; + private final Optional maybeModuleBuilder; + + ModuleOrModuleBuilder(final Module module) { + maybeModule = Optional.of(module); + maybeModuleBuilder = Optional.absent(); + } + + ModuleOrModuleBuilder(final ModuleBuilder moduleBuilder) { + maybeModule = Optional.absent(); + maybeModuleBuilder = Optional.of(moduleBuilder); + } + boolean isModule(){ + return maybeModule.isPresent(); + } + boolean isModuleBuilder(){ + return maybeModuleBuilder.isPresent(); + } + Module getModule(){ + return maybeModule.get(); + } + ModuleBuilder getModuleBuilder(){ + return maybeModuleBuilder.get(); + } + + static List fromAll(final Collection modules, final Collection moduleBuilders) { + List result = new ArrayList<>(modules.size() + moduleBuilders.size()); + for(Module m: modules){ + result.add(new ModuleOrModuleBuilder(m)); + } + for (ModuleBuilder mb : moduleBuilders) { + result.add(new ModuleOrModuleBuilder(mb)); + } + return result; + } +}