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