DependencyUtil.java
3.78 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
/*
* Decompiled with CFR 0_118.
*
* Could not load the following classes:
* javax.jcr.RepositoryException
* org.slf4j.Logger
* org.slf4j.LoggerFactory
*/
package com.day.jcr.vault.packaging;
import com.day.jcr.vault.packaging.CyclicDependencyException;
import com.day.jcr.vault.packaging.Dependency;
import com.day.jcr.vault.packaging.JcrPackage;
import com.day.jcr.vault.packaging.JcrPackageDefinition;
import com.day.jcr.vault.packaging.PackageId;
import com.day.jcr.vault.packaging.VaultPackage;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.jcr.RepositoryException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/*
* This class specifies class file version 49.0 but uses Java 6 signatures. Assumed Java 6.
*/
@Deprecated
public class DependencyUtil {
private static final Logger log = LoggerFactory.getLogger(DependencyUtil.class);
public static <T extends VaultPackage> void sort(Collection<T> packages) throws CyclicDependencyException {
LinkedHashMap<PackageId, Dependency[]> list = new LinkedHashMap<PackageId, Dependency[]>();
LinkedHashMap<PackageId, VaultPackage> byId = new LinkedHashMap<PackageId, VaultPackage>();
for (VaultPackage pack : packages) {
list.put(pack.getId(), pack.getDependencies());
byId.put(pack.getId(), pack);
}
packages.clear();
for (PackageId id : DependencyUtil.resolve(list)) {
packages.add((VaultPackage)((VaultPackage)byId.remove(id)));
}
}
public static <T extends JcrPackage> void sortPackages(Collection<T> packages) throws CyclicDependencyException, RepositoryException {
LinkedHashMap<PackageId, Dependency[]> list = new LinkedHashMap<PackageId, Dependency[]>();
LinkedHashMap<PackageId, JcrPackage> byId = new LinkedHashMap<PackageId, JcrPackage>();
for (JcrPackage pack : packages) {
PackageId id = pack.getDefinition().getId();
list.put(id, pack.getDefinition().getDependencies());
byId.put(id, pack);
}
packages.clear();
for (PackageId id : DependencyUtil.resolve(list)) {
packages.add((JcrPackage)((JcrPackage)byId.remove(id)));
}
}
public static List<PackageId> resolve(Map<PackageId, Dependency[]> list) throws CyclicDependencyException {
Dependency[] fake = new Dependency[list.size()];
int i = 0;
for (Map.Entry<PackageId, Dependency[]> entry : list.entrySet()) {
fake[i++] = new Dependency(entry.getKey());
}
LinkedHashMap<PackageId, Boolean> result = new LinkedHashMap<PackageId, Boolean>(list.size());
DependencyUtil.resolve(fake, list, result);
return new ArrayList<PackageId>(result.keySet());
}
private static void resolve(Dependency[] deps, Map<PackageId, Dependency[]> list, Map<PackageId, Boolean> result) throws CyclicDependencyException {
for (Dependency dep : deps) {
for (Map.Entry<PackageId, Dependency[]> entry : list.entrySet()) {
PackageId id = entry.getKey();
if (!dep.matches(id)) continue;
Boolean res = result.get(id);
if (res != null && !res.booleanValue()) {
log.error("Package dependencies cause cycle.");
throw new CyclicDependencyException();
}
if (res == null) {
res = false;
result.put(id, res);
}
DependencyUtil.resolve(entry.getValue(), list, result);
if (res.booleanValue()) continue;
result.remove(id);
result.put(id, true);
}
}
}
}