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 @Override
92 public void filterVersions(VersionFilterContext context) throws RepositoryException {
93 for (int i = 0, n = filters.length; i < n && context.getCount() > 0; i++) {
94 filters[i].filterVersions(context);
95 }
96 }
97
98 @Override
99 public VersionFilter deriveChildFilter(DependencyCollectionContext context) {
100 VersionFilter[] children = null;
101 int removed = 0;
102 for (int i = 0, n = filters.length; i < n; i++) {
103 VersionFilter child = filters[i].deriveChildFilter(context);
104 if (children != null) {
105 children[i - removed] = child;
106 } else if (child != filters[i]) {
107 children = new VersionFilter[filters.length];
108 System.arraycopy(filters, 0, children, 0, i);
109 children[i - removed] = child;
110 }
111 if (child == null) {
112 removed++;
113 }
114 }
115 if (children == null) {
116 return this;
117 }
118 if (removed > 0) {
119 int count = filters.length - removed;
120 if (count <= 0) {
121 return null;
122 }
123 if (count == 1) {
124 return children[0];
125 }
126 VersionFilter[] tmp = new VersionFilter[count];
127 System.arraycopy(children, 0, tmp, 0, count);
128 children = tmp;
129 }
130 return new ChainedVersionFilter(children);
131 }
132
133 @Override
134 public boolean equals(Object obj) {
135 if (this == obj) {
136 return true;
137 } else if (null == obj || !getClass().equals(obj.getClass())) {
138 return false;
139 }
140
141 ChainedVersionFilter that = (ChainedVersionFilter) obj;
142 return Arrays.equals(filters, that.filters);
143 }
144
145 @Override
146 public int hashCode() {
147 if (hashCode == 0) {
148 int hash = getClass().hashCode();
149 hash = hash * 31 + Arrays.hashCode(filters);
150 hashCode = hash;
151 }
152 return hashCode;
153 }
154 }