001
014
015 package com.liferay.portal.kernel.plugin;
016
017 import com.liferay.portal.kernel.util.CharPool;
018 import com.liferay.portal.kernel.util.GetterUtil;
019 import com.liferay.portal.kernel.util.StringBundler;
020 import com.liferay.portal.kernel.util.StringPool;
021 import com.liferay.portal.kernel.util.Validator;
022
023 import java.io.Serializable;
024
025 import java.util.Map;
026 import java.util.StringTokenizer;
027 import java.util.concurrent.ConcurrentHashMap;
028
029
032 public class Version implements Comparable<Version>, Serializable {
033
034 public static final String UNKNOWN = "unknown";
035
036 public static Version getInstance(String version) {
037 Version versionObj = _versions.get(version);
038
039 if (versionObj == null) {
040 versionObj = new Version(version);
041
042 _versions.put(version, versionObj);
043 }
044
045 return versionObj;
046 }
047
048 public static Version incrementBugFix(Version version) {
049 String bugFix = version.getBugFix();
050
051 int bugFixInt = GetterUtil.getInteger(bugFix);
052
053 if (bugFixInt > 0) {
054 bugFix = String.valueOf(bugFixInt + 1);
055 }
056
057 return getInstance(
058 _toString(
059 version.getMajor(), version.getMinor(), bugFix,
060 version.getBuildNumber()));
061 }
062
063 public static Version incrementBuildNumber(Version version) {
064 String buildNumber = version.getBuildNumber();
065
066 int buildNumberInt = GetterUtil.getInteger(buildNumber);
067
068 if (buildNumberInt > 0) {
069 buildNumber = String.valueOf(buildNumberInt + 1);
070 }
071
072 return getInstance(
073 _toString(
074 version.getMajor(), version.getMinor(), version.getBugFix(),
075 buildNumber));
076 }
077
078 public static Version incrementMajor(Version version) {
079 String major = version.getMajor();
080
081 int majorInt = GetterUtil.getInteger(major);
082
083 if (majorInt > 0) {
084 major = String.valueOf(majorInt + 1);
085 }
086
087 return getInstance(
088 _toString(
089 major, version.getMinor(), version.getBugFix(),
090 version.getBuildNumber()));
091 }
092
093 public static Version incrementMinor(Version version) {
094 String minor = version.getMinor();
095
096 int minorInt = GetterUtil.getInteger(minor);
097
098 if (minorInt > 0) {
099 minor = String.valueOf(minorInt + 1);
100 }
101
102 return getInstance(
103 _toString(
104 version.getMajor(), minor, version.getBugFix(),
105 version.getBuildNumber()));
106 }
107
108 @Override
109 public int compareTo(Version version) {
110 if (version == null) {
111 return 1;
112 }
113
114
115
116 if (version.toString().equals(UNKNOWN)) {
117 return 1;
118 }
119
120 if (toString().equals(UNKNOWN)) {
121 return -1;
122 }
123
124 int result = _compareAsIntegers(getMajor(), version.getMajor());
125
126 if (result != 0) {
127 return result;
128 }
129
130 result = _compareAsIntegers(getMinor(), version.getMinor());
131
132 if (result != 0) {
133 return result;
134 }
135
136 result = _compareAsIntegers(getBugFix(), version.getBugFix());
137
138 if (result != 0) {
139 return result;
140 }
141
142 return _compareAsIntegers(getBuildNumber(), version.getBuildNumber());
143 }
144
145 @Override
146 public boolean equals(Object obj) {
147 if (this == obj) {
148 return true;
149 }
150
151 if (!(obj instanceof Version)) {
152 return false;
153 }
154
155 Version version = (Version)obj;
156
157 String versionString1 = toString();
158 String versionString2 = version.toString();
159
160 if (versionString1.equals(UNKNOWN) || versionString2.equals(UNKNOWN)) {
161 return false;
162 }
163
164 return versionString1.equals(versionString2);
165 }
166
167 public String getBugFix() {
168 if (_bugFix == null) {
169 return "0";
170 }
171
172 return _bugFix;
173 }
174
175 public String getBuildNumber() {
176 return _buildNumber;
177 }
178
179 public String getMajor() {
180 if (_major == null) {
181 return "0";
182 }
183
184 return _major;
185 }
186
187 public String getMinor() {
188 if (_minor == null) {
189 return "0";
190 }
191
192 return _minor;
193 }
194
195 @Override
196 public int hashCode() {
197 return toString().hashCode();
198 }
199
200 public boolean includes(Version version) {
201 if (equals(version)) {
202 return true;
203 }
204
205 if (getMajor().equals(StringPool.STAR)) {
206 return true;
207 }
208
209 if (getMajor().equals(version.getMajor())) {
210 if (getMinor().equals(StringPool.STAR)) {
211 return true;
212 }
213
214 if (getMinor().equals(version.getMinor())) {
215 if (getBugFix().equals(StringPool.STAR)) {
216 return true;
217 }
218
219 if (getBugFix().equals(version.getBugFix())) {
220 if (getBuildNumber().equals(StringPool.STAR) ||
221 getBuildNumber().equals(version.getBuildNumber())) {
222
223 return true;
224 }
225 else if (_contains(
226 getBuildNumber(), version.getBuildNumber())) {
227
228 return true;
229 }
230 }
231 else if (_contains(getBugFix(), version.getBugFix())) {
232 return true;
233 }
234 }
235 else if (_contains(getMinor(), version.getMinor())) {
236 return true;
237 }
238 }
239 else if (_contains(getMajor(), version.getMajor())) {
240 return true;
241 }
242
243 return false;
244 }
245
246 public boolean isLaterVersionThan(String version) {
247 if (compareTo(getInstance(version)) > 0) {
248 return true;
249 }
250 else {
251 return false;
252 }
253 }
254
255 public boolean isPreviousVersionThan(String version) {
256 if (compareTo(getInstance(version)) < 0) {
257 return true;
258 }
259 else {
260 return false;
261 }
262 }
263
264 public boolean isSameVersionAs(String version) {
265 if (compareTo(getInstance(version)) == 0) {
266 return true;
267 }
268 else {
269 return false;
270 }
271 }
272
273 @Override
274 public String toString() {
275 return _toString(_major, _minor, _bugFix, _buildNumber);
276 }
277
278 protected Version(String version) {
279 int index = version.indexOf(CharPool.DASH);
280
281 if (index != -1) {
282 version = version.substring(0, index);
283 }
284
285 StringTokenizer st = new StringTokenizer(version, _SEPARATOR);
286
287 _major = st.nextToken();
288
289 if (st.hasMoreTokens()) {
290 _minor = st.nextToken();
291 }
292
293 if (st.hasMoreTokens()) {
294 _bugFix = st.nextToken();
295 }
296
297 if (st.hasMoreTokens()) {
298 _buildNumber = st.nextToken();
299 }
300 }
301
302 private static boolean _contains(
303 String containerString, String numberString) {
304
305 if (containerString.endsWith(StringPool.PLUS)) {
306 String containerNumberString = containerString.substring(
307 0, containerString.length() - 1);
308
309 try {
310 int containerNumber = GetterUtil.getInteger(
311 containerNumberString);
312 int number = GetterUtil.getInteger(numberString);
313
314 return containerNumber <= number;
315 }
316 catch (NumberFormatException nfe) {
317 return false;
318 }
319 }
320
321 return false;
322 }
323
324 private static String _toString(
325 String major, String minor, String bugFix, String buildNumber) {
326
327 StringBundler sb = new StringBundler();
328
329 sb.append(major);
330
331 if (Validator.isNotNull(minor)) {
332 sb.append(_SEPARATOR);
333 sb.append(minor);
334
335 if (Validator.isNotNull(bugFix)) {
336 sb.append(_SEPARATOR);
337 sb.append(bugFix);
338
339 if (Validator.isNotNull(buildNumber)) {
340 sb.append(_SEPARATOR);
341 sb.append(buildNumber);
342 }
343 }
344 }
345
346 return sb.toString();
347 }
348
349 private int _compareAsIntegers(String first, String second) {
350 int firstInteger = GetterUtil.getInteger(first);
351 int secondInteger = GetterUtil.getInteger(second);
352
353 if (firstInteger < secondInteger) {
354 return -1;
355 }
356 else if (firstInteger == secondInteger) {
357 return 0;
358 }
359 else {
360 return 1;
361 }
362 }
363
364 private static final String _SEPARATOR = StringPool.PERIOD;
365
366 private static Map<String, Version> _versions =
367 new ConcurrentHashMap<String, Version>();
368
369 private String _bugFix;
370 private String _buildNumber;
371 private String _major;
372 private String _minor;
373
374 }