Beispiel #1
0
 @Override
 public Module apply(final TopologicalSort.Node input) {
   if (input == null) {
     return null;
   }
   ModuleOrModuleBuilder moduleOrModuleBuilder = ((ModuleNodeImpl) input).getReference();
   return moduleOrModuleBuilder.getModule();
 }
Beispiel #2
0
  public static List<ModuleBuilder> sortWithContext(
      final SchemaContext context, final ModuleBuilder... builders) {
    List<ModuleOrModuleBuilder> all =
        ModuleOrModuleBuilder.fromAll(context.getModules(), asList(builders));

    List<TopologicalSort.Node> sorted = sortInternal(all);
    // Cast to ModuleBuilder from Node if possible and return
    return Lists.transform(
        sorted,
        new Function<TopologicalSort.Node, ModuleBuilder>() {

          @Override
          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;
            }
          }
        });
  }
Beispiel #3
0
 /**
  * Topological sort of module dependency graph.
  *
  * @return Sorted list of Modules. Modules can be further processed in returned order.
  */
 public static List<Module> sort(final Module... modules) {
   List<TopologicalSort.Node> sorted =
       sortInternal(
           ModuleOrModuleBuilder.fromAll(asList(modules), Collections.<ModuleBuilder>emptyList()));
   // Cast to Module from Node and return
   return Lists.transform(sorted, TOPOLOGY_FUNCTION);
 }
Beispiel #4
0
  /** Extract dependencies from module builders or modules to fill dependency graph */
  private static void processModules(
      final Map<String, Map<Date, ModuleNodeImpl>> moduleGraph,
      final Iterable<ModuleOrModuleBuilder> builders) {

    // Process nodes
    for (ModuleOrModuleBuilder momb : builders) {

      String name;
      Date rev;

      if (momb.isModule()) {
        name = momb.getModule().getName();
        rev = momb.getModule().getRevision();
      } else {
        name = momb.getModuleBuilder().getName();
        rev = momb.getModuleBuilder().getRevision();
      }

      if (rev == null) {
        rev = DEFAULT_REVISION;
      }

      if (moduleGraph.get(name) == null) {
        moduleGraph.put(name, Maps.<Date, ModuleNodeImpl>newHashMap());
      }

      if (moduleGraph.get(name).get(rev) != null) {
        ex(String.format("Module:%s with revision:%s declared twice", name, formatRevDate(rev)));
      }

      moduleGraph.get(name).put(rev, new ModuleNodeImpl(name, rev, momb));
    }
  }
Beispiel #5
0
 public static List<ModuleBuilder> sort(final Collection<ModuleBuilder> builders) {
   List<TopologicalSort.Node> sorted =
       sortInternal(ModuleOrModuleBuilder.fromAll(Collections.<Module>emptySet(), builders));
   return Lists.transform(sorted, NODE_TO_MODULEBUILDER);
 }
Beispiel #6
0
  /** Extract module:revision from module builders */
  private static void processDependencies(
      final Map<String, Map<Date, ModuleNodeImpl>> moduleGraph,
      final Iterable<ModuleOrModuleBuilder> mmbs) {
    Map<URI, ModuleOrModuleBuilder> allNS = new HashMap<>();

    // Create edges in graph
    for (ModuleOrModuleBuilder mmb : mmbs) {
      Map<String, Date> imported = Maps.newHashMap();

      String fromName;
      Date fromRevision;
      Collection<ModuleImport> 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

      if (fromRevision == null) {
        fromRevision = DEFAULT_REVISION;
      }

      for (ModuleImport imprt : imports) {
        String toName = imprt.getModuleName();
        Date toRevision = imprt.getRevision() == null ? DEFAULT_REVISION : imprt.getRevision();

        ModuleNodeImpl from = moduleGraph.get(fromName).get(fromRevision);

        ModuleNodeImpl to =
            getModuleByNameAndRevision(moduleGraph, fromName, fromRevision, toName, toRevision);

        /*
         * Check imports: If module is imported twice with different
         * revisions then throw exception
         */
        if (imported.get(toName) != null
            && !imported.get(toName).equals(toRevision)
            && !imported.get(toName).equals(DEFAULT_REVISION)
            && !toRevision.equals(DEFAULT_REVISION)) {
          ex(
              String.format(
                  "Module:%s imported twice with different revisions:%s, %s",
                  toName, formatRevDate(imported.get(toName)), formatRevDate(toRevision)));
        }

        imported.put(toName, toRevision);

        from.addEdge(to);
      }
    }
  }