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