/** * Adds an exact dependency to the give package if it is not already contained in the given list. * @param deps the original dependencies * @param id the id to add * @return the new array of dependencies, or {@code deps} if nothing changed. */ public static Dependency[] addExact(@Nonnull Dependency[] deps, @Nonnull PackageId id) { if (matches(deps, id)) { return deps; } Dependency[] newDeps = new Dependency[deps.length + 1]; System.arraycopy(deps, 0, newDeps, 0, deps.length); newDeps[deps.length] = new Dependency(id); return newDeps; }
private static Dependency readDependency(Element child) { return Dependency.fromString(child.getAttribute(ATTR_PACKAGE_ID)); }
/** * Adds an dependency to the give package if it is not already contained in the given list. version ranges are * current ignored. * * @param deps the original dependencies * @param dep the dependency to add * @return the new array of dependencies, or {@code deps} if nothing changed. */ public static Dependency[] add(@Nonnull Dependency[] deps, @Nonnull Dependency dep) { for (Dependency d: deps) { if (d.getName().equals(dep.getName()) && d.getGroup().equals(dep.getGroup())) { return deps; } } Dependency[] newDeps = new Dependency[deps.length + 1]; System.arraycopy(deps, 0, newDeps, 0, deps.length); newDeps[deps.length] = dep; return newDeps; }
/** * {@inheritDoc} */ public void setDependencies(@Nonnull Dependency[] dependencies, boolean autoSave) { try { final List<Value> values = new ArrayList<>(dependencies.length); final ValueFactory fac = defNode.getSession().getValueFactory(); for (Dependency d: dependencies) { if (d != null) { values.add(fac.createValue(d.toString())); } } defNode.setProperty(PN_DEPENDENCIES, values.toArray(new Value[values.size()])); if (autoSave) { defNode.getSession().save(); } } catch (RepositoryException e) { log.error("Error during setDependencies()", e); } }
/** * {@inheritDoc} */ @Override public Dependency[] getDependencies() { String deps = getProperty(NAME_DEPENDENCIES); if (deps == null) { return Dependency.EMPTY; } else { return Dependency.parse(deps); } }
PackageId bestId = null; for (Node root: getPackageRoots()) { if (!root.hasNode(dependency.getGroup())) { continue; Node groupNode = root.getNode(dependency.getGroup()); NodeIterator iter = groupNode.getNodes(); while (iter.hasNext()) { if (dependency.matches(id)) { if (bestId == null || id.getVersion().compareTo(bestId.getVersion()) > 0) { bestId = id;
/** * Checks if any of the dependencies matches the given id * @param deps the list of dependencies * @param id the id * @return {@code true} if matches */ public static boolean matches(@Nonnull Dependency[] deps, @Nonnull PackageId id) { for (Dependency dep: deps) { if (dep.matches(id)) { return true; } } return false; }
DependencyReport report = registry.analyzeDependencies(id, false); if (report.getUnresolvedDependencies().length > 0) { throw new DependencyException("Package has unresolved dependencies: " + Dependency.toString(report.getUnresolvedDependencies()));
private static void resolve(Dependency[] deps, Map<PackageId, Dependency[]> list, Map<PackageId, Boolean> result) throws CyclicDependencyException { // find the dep in the list for (Dependency dep: deps) { for (Map.Entry<PackageId, Dependency[]> entry: list.entrySet()) { PackageId id = entry.getKey(); if (dep.matches(id)) { Boolean res = result.get(id); if (res != null && !res) { log.error("Package dependencies cause cycle."); throw new CyclicDependencyException(); } else if (res == null) { result.put(id, res = false); } resolve(entry.getValue(), list, result); // shove at the end of the list if not resolved if (!res) { result.remove(id); result.put(id, true); } } } } }
/** * Returns dependencies from the given strings. * @param str the strings * @return the dependencies */ @Nonnull public static Dependency[] fromString(@Nonnull String ... str) { List<Dependency> deps = new ArrayList<>(str.length); for (String s : str) { Dependency dep = Dependency.fromString(s); if (dep != null) { deps.add(dep); } } return deps.toArray(new Dependency[deps.size()]); }
for (Dependency dependency : dependencies) { attrs = new AttributesImpl(); attrs.addAttribute(null, null, ATTR_PACKAGE_ID, "CDATA", dependency.toString()); ser.startElement(null, null, TAG_DEPENDENCY, attrs); ser.endElement(TAG_DEPENDENCY);
/** * {@inheritDoc} */ @Nonnull @Override public PackageId[] usage(PackageId id) throws IOException { TreeSet<PackageId> usages = new TreeSet<PackageId>(); for (PackageId pid : packages()) { try (RegisteredPackage pkg = open(pid)) { if (pkg == null || !pkg.isInstalled()) { continue; } // noinspection resource for (Dependency dep : pkg.getPackage().getDependencies()) { if (dep.matches(id)) { usages.add(pid); break; } } } } return usages.toArray(new PackageId[usages.size()]); }
/** * Resolves a list of resolutions respecting their internal dependency references. * @param list list of resolutions * @return a new list of resolutions * @throws CyclicDependencyException if a cyclic dependency is detected */ public static List<PackageId> resolve(Map<PackageId, Dependency[]> list) throws CyclicDependencyException { // create fake deplist Dependency[] fake = new Dependency[list.size()]; int i=0; for (Map.Entry<PackageId, Dependency[]> entry: list.entrySet()) { fake[i++] = new Dependency(entry.getKey()); } Map<PackageId, Boolean> result = new LinkedHashMap<PackageId, Boolean>(list.size()); resolve(fake, list, result); return new ArrayList<PackageId>(result.keySet()); }
if (c == ',') { if (!inRange) { deps.add(Dependency.fromString(str.substring(start, i))); start = i + 1; Dependency dep = Dependency.fromString(str.substring(start)); if (dep != null) { deps.add(dep);
/** * Load the given properties from the content * @param props the properties to load */ private void loadProperties(Properties props) { PackageId id = getId(); setProperty(props, VaultPackage.NAME_VERSION, id.getVersionString()); setProperty(props, VaultPackage.NAME_NAME, id.getName()); setProperty(props, VaultPackage.NAME_GROUP, id.getGroup()); setProperty(props, VaultPackage.NAME_BUILD_COUNT, get(PN_BUILD_COUNT)); setProperty(props, VaultPackage.NAME_DESCRIPTION, get(PN_DESCRIPTION)); setProperty(props, VaultPackage.NAME_REQUIRES_ROOT, get(PN_REQUIRES_ROOT)); setProperty(props, VaultPackage.NAME_REQUIRES_RESTART, get(PN_REQUIRES_RESTART)); setProperty(props, VaultPackage.NAME_LAST_MODIFIED, getCalendar(PN_LASTMODIFIED)); setProperty(props, VaultPackage.NAME_LAST_MODIFIED_BY, get(PN_LASTMODIFIED_BY)); setProperty(props, VaultPackage.NAME_LAST_WRAPPED, getCalendar(PN_LAST_WRAPPED)); setProperty(props, VaultPackage.NAME_LAST_WRAPPED_BY, get(PN_LAST_WRAPPED_BY)); setProperty(props, VaultPackage.NAME_CREATED, getCalendar(PN_CREATED)); setProperty(props, VaultPackage.NAME_CREATED_BY, get(PN_CREATED_BY)); setProperty(props, VaultPackage.NAME_DEPENDENCIES, Dependency.toString(getDependencies())); setProperty(props, VaultPackage.NAME_AC_HANDLING, get(PN_AC_HANDLING)); setProperty(props, VaultPackage.NAME_CND_PATTERN, get(PN_CND_PATTERN)); }
/** * {@inheritDoc} */ @Override public PackageId resolve(Dependency dependency, boolean onlyInstalled) throws IOException { PackageId bestId = null; for (PackageId id : packages()) { if (!onlyInstalled || isInstalled(id)) { if (dependency.matches(id)) { if (bestId == null || id.getVersion().compareTo(bestId.getVersion()) > 0) { bestId = id; } } } } return bestId; }
range = segs[2]; return new Dependency(groupId, name, range == null ? null : VersionRange.fromString(range));
/** * {@inheritDoc} */ public Dependency[] getDependencies() { try { if (defNode.hasProperty(PN_DEPENDENCIES)) { Property p = defNode.getProperty(PN_DEPENDENCIES); List<Dependency> deps = new LinkedList<>(); if (p.getDefinition().isMultiple()) { for (Value v: p.getValues()) { Dependency dep = Dependency.fromString(v.getString()); if (dep != null) { deps.add(dep); } } } else { Dependency dep = Dependency.fromString(p.getString()); if (dep != null) { deps.add(dep); } } return deps.toArray(new Dependency[deps.size()]); } } catch (RepositoryException e) { log.error("Error during getDependencies()", e); } return Dependency.EMPTY; }
Dependency autoDependency = hasOwnContent ? new Dependency(pkg.getId()) : null; registerSubPackages(pkg, packagesRoot, DEFAULT_PACKAGE_ROOT_PATH, replace, subpackages, autoDependency); dispatch(Type.EXTRACT_SUB_PACKAGES, pkg.getId(), subpackages.keySet().toArray(new PackageId[subpackages.size()]));