1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.eclipse.aether.util.graph.version;
20
21 import java.util.Arrays;
22 import java.util.Collection;
23
24 import org.eclipse.aether.RepositoryException;
25 import org.eclipse.aether.collection.DependencyCollectionContext;
26 import org.eclipse.aether.collection.VersionFilter;
27
28
29
30
31
32 public final class ChainedVersionFilter implements VersionFilter {
33
34 private final VersionFilter[] filters;
35
36 private int hashCode;
37
38
39
40
41
42
43
44
45 public static VersionFilter newInstance(VersionFilter filter1, VersionFilter filter2) {
46 if (filter1 == null) {
47 return filter2;
48 }
49 if (filter2 == null) {
50 return filter1;
51 }
52 return new ChainedVersionFilter(new VersionFilter[] {filter1, filter2});
53 }
54
55
56
57
58
59
60
61 public static VersionFilter newInstance(VersionFilter... filters) {
62 if (filters.length <= 1) {
63 if (filters.length <= 0) {
64 return null;
65 }
66 return filters[0];
67 }
68 return new ChainedVersionFilter(filters.clone());
69 }
70
71
72
73
74
75
76
77 public static VersionFilter newInstance(Collection<? extends VersionFilter> filters) {
78 if (filters.size() <= 1) {
79 if (filters.isEmpty()) {
80 return null;
81 }
82 return filters.iterator().next();
83 }
84 return new ChainedVersionFilter(filters.toArray(new VersionFilter[0]));
85 }
86
87 private ChainedVersionFilter(VersionFilter[] filters) {
88 this.filters = filters;
89 }
90
91 public void filterVersions(VersionFilterContext context) throws RepositoryException {
92 for (int i = 0, n = filters.length; i < n && context.getCount() > 0; i++) {
93 filters[i].filterVersions(context);
94 }
95 }
96
97 public VersionFilter deriveChildFilter(DependencyCollectionContext context) {
98 VersionFilter[] children = null;
99 int removed = 0;
100 for (int i = 0, n = filters.length; i < n; i++) {
101 VersionFilter child = filters[i].deriveChildFilter(context);
102 if (children != null) {
103 children[i - removed] = child;
104 } else if (child != filters[i]) {
105 children = new VersionFilter[filters.length];
106 System.arraycopy(filters, 0, children, 0, i);
107 children[i - removed] = child;
108 }
109 if (child == null) {
110 removed++;
111 }
112 }
113 if (children == null) {
114 return this;
115 }
116 if (removed > 0) {
117 int count = filters.length - removed;
118 if (count <= 0) {
119 return null;
120 }
121 if (count == 1) {
122 return children[0];
123 }
124 VersionFilter[] tmp = new VersionFilter[count];
125 System.arraycopy(children, 0, tmp, 0, count);
126 children = tmp;
127 }
128 return new ChainedVersionFilter(children);
129 }
130
131 @Override
132 public boolean equals(Object obj) {
133 if (this == obj) {
134 return true;
135 } else if (null == obj || !getClass().equals(obj.getClass())) {
136 return false;
137 }
138
139 ChainedVersionFilter that = (ChainedVersionFilter) obj;
140 return Arrays.equals(filters, that.filters);
141 }
142
143 @Override
144 public int hashCode() {
145 if (hashCode == 0) {
146 int hash = getClass().hashCode();
147 hash = hash * 31 + Arrays.hashCode(filters);
148 hashCode = hash;
149 }
150 return hashCode;
151 }
152 }