001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * The contents of this file are subject to the terms of the Liferay Enterprise
005     * Subscription License ("License"). You may not use this file except in
006     * compliance with the License. You can obtain a copy of the License by
007     * contacting Liferay, Inc. See the License for the specific language governing
008     * permissions and limitations under the License, including but not limited to
009     * distribution rights of the Software.
010     *
011     *
012     *
013     */
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    /**
030     * @author Jorge Ferrer
031     */
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(), version.getQualifier()));
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, version.getQualifier()));
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(), version.getQualifier()));
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(), version.getQualifier()));
106            }
107    
108            @Override
109            public int compareTo(Version version) {
110                    if (version == null) {
111                            return 1;
112                    }
113    
114                    // Unknown is always considered a lower version
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            public String getQualifier() {
196                    if (_qualifier == null) {
197                            return StringPool.BLANK;
198                    }
199    
200                    return _qualifier;
201            }
202    
203            @Override
204            public int hashCode() {
205                    return toString().hashCode();
206            }
207    
208            public boolean includes(Version version) {
209                    if (equals(version)) {
210                            return true;
211                    }
212    
213                    if (getMajor().equals(StringPool.STAR)) {
214                            return true;
215                    }
216    
217                    if (getMajor().equals(version.getMajor())) {
218                            if (getMinor().equals(StringPool.STAR)) {
219                                    return true;
220                            }
221    
222                            if (getMinor().equals(version.getMinor())) {
223                                    if (getBugFix().equals(StringPool.STAR)) {
224                                            return true;
225                                    }
226    
227                                    if (getBugFix().equals(version.getBugFix())) {
228                                            if (getBuildNumber().equals(StringPool.STAR) ||
229                                                    getBuildNumber().equals(version.getBuildNumber())) {
230    
231                                                    return true;
232                                            }
233                                            else if (_contains(
234                                                                    getBuildNumber(), version.getBuildNumber())) {
235    
236                                                    return true;
237                                            }
238                                    }
239                                    else if (_contains(getBugFix(), version.getBugFix())) {
240                                            return true;
241                                    }
242                            }
243                            else if (_contains(getMinor(), version.getMinor())) {
244                                    return true;
245                            }
246                    }
247                    else if (_contains(getMajor(), version.getMajor())) {
248                            return true;
249                    }
250    
251                    return false;
252            }
253    
254            public boolean isLaterVersionThan(String version) {
255                    if (compareTo(getInstance(version)) > 0) {
256                            return true;
257                    }
258                    else {
259                            return false;
260                    }
261            }
262    
263            public boolean isPreviousVersionThan(String version) {
264                    if (compareTo(getInstance(version)) < 0) {
265                            return true;
266                    }
267                    else {
268                            return false;
269                    }
270            }
271    
272            public boolean isSameVersionAs(String version) {
273                    if (compareTo(getInstance(version)) == 0) {
274                            return true;
275                    }
276                    else {
277                            return false;
278                    }
279            }
280    
281            @Override
282            public String toString() {
283                    return _toString(_major, _minor, _bugFix, _buildNumber, _qualifier);
284            }
285    
286            protected Version(String version) {
287                    int index = version.indexOf(CharPool.DASH);
288    
289                    if (index != -1) {
290                            _qualifier = version.substring(index + 1);
291    
292                            version = version.substring(0, index);
293                    }
294    
295                    StringTokenizer st = new StringTokenizer(version, _SEPARATOR);
296    
297                    _major = st.nextToken();
298    
299                    if (st.hasMoreTokens()) {
300                            _minor = st.nextToken();
301                    }
302    
303                    if (st.hasMoreTokens()) {
304                            _bugFix = st.nextToken();
305                    }
306    
307                    if (st.hasMoreTokens()) {
308                            _buildNumber = st.nextToken();
309                    }
310            }
311    
312            private static boolean _contains(
313                    String containerString, String numberString) {
314    
315                    if (containerString.endsWith(StringPool.PLUS)) {
316                            String containerNumberString = containerString.substring(
317                                    0, containerString.length() - 1);
318    
319                            try {
320                                    int containerNumber = GetterUtil.getInteger(
321                                            containerNumberString);
322                                    int number = GetterUtil.getInteger(numberString);
323    
324                                    return containerNumber <= number;
325                            }
326                            catch (NumberFormatException nfe) {
327                                    return false;
328                            }
329                    }
330    
331                    return false;
332            }
333    
334            private static String _toString(
335                    String major, String minor, String bugFix, String buildNumber,
336                    String qualifier) {
337    
338                    StringBundler sb = new StringBundler();
339    
340                    sb.append(major);
341    
342                    if (Validator.isNotNull(minor)) {
343                            sb.append(_SEPARATOR);
344                            sb.append(minor);
345    
346                            if (Validator.isNotNull(bugFix)) {
347                                    sb.append(_SEPARATOR);
348                                    sb.append(bugFix);
349    
350                                    if (Validator.isNotNull(buildNumber)) {
351                                            sb.append(_SEPARATOR);
352                                            sb.append(buildNumber);
353                                    }
354                            }
355                    }
356    
357                    if (Validator.isNotNull(qualifier)) {
358                            sb.append(CharPool.DASH);
359                            sb.append(qualifier);
360                    }
361    
362                    return sb.toString();
363            }
364    
365            private int _compareAsIntegers(String first, String second) {
366                    int firstInteger = GetterUtil.getInteger(first);
367                    int secondInteger = GetterUtil.getInteger(second);
368    
369                    if (firstInteger < secondInteger) {
370                            return -1;
371                    }
372                    else if (firstInteger == secondInteger) {
373                            return 0;
374                    }
375                    else {
376                            return 1;
377                    }
378            }
379    
380            private static final String _SEPARATOR = StringPool.PERIOD;
381    
382            private static Map<String, Version> _versions =
383                    new ConcurrentHashMap<String, Version>();
384    
385            private String _bugFix;
386            private String _buildNumber;
387            private String _major;
388            private String _minor;
389            private String _qualifier;
390    
391    }