diff options
Diffstat (limited to 'src/org/jivesoftware/smackx/workgroup/util/ModelUtil.java')
| -rw-r--r-- | src/org/jivesoftware/smackx/workgroup/util/ModelUtil.java | 322 |
1 files changed, 322 insertions, 0 deletions
diff --git a/src/org/jivesoftware/smackx/workgroup/util/ModelUtil.java b/src/org/jivesoftware/smackx/workgroup/util/ModelUtil.java new file mode 100644 index 0000000..0a4df15 --- /dev/null +++ b/src/org/jivesoftware/smackx/workgroup/util/ModelUtil.java @@ -0,0 +1,322 @@ +/**
+ * Copyright 2003-2007 Jive Software.
+ *
+ * All rights reserved. Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jivesoftware.smackx.workgroup.util;
+
+import java.util.*;
+
+/**
+ * Utility methods frequently used by data classes and design-time
+ * classes.
+ */
+public final class ModelUtil {
+ private ModelUtil() {
+ // Prevents instantiation.
+ }
+
+ /**
+ * This is a utility method that compares two objects when one or
+ * both of the objects might be <CODE>null</CODE> The result of
+ * this method is determined as follows:
+ * <OL>
+ * <LI>If <CODE>o1</CODE> and <CODE>o2</CODE> are the same object
+ * according to the <CODE>==</CODE> operator, return
+ * <CODE>true</CODE>.
+ * <LI>Otherwise, if either <CODE>o1</CODE> or <CODE>o2</CODE> is
+ * <CODE>null</CODE>, return <CODE>false</CODE>.
+ * <LI>Otherwise, return <CODE>o1.equals(o2)</CODE>.
+ * </OL>
+ * <p/>
+ * This method produces the exact logically inverted result as the
+ * {@link #areDifferent(Object, Object)} method.<P>
+ * <p/>
+ * For array types, one of the <CODE>equals</CODE> methods in
+ * {@link java.util.Arrays} should be used instead of this method.
+ * Note that arrays with more than one dimension will require some
+ * custom code in order to implement <CODE>equals</CODE> properly.
+ */
+ public static final boolean areEqual(Object o1, Object o2) {
+ if (o1 == o2) {
+ return true;
+ }
+ else if (o1 == null || o2 == null) {
+ return false;
+ }
+ else {
+ return o1.equals(o2);
+ }
+ }
+
+ /**
+ * This is a utility method that compares two Booleans when one or
+ * both of the objects might be <CODE>null</CODE> The result of
+ * this method is determined as follows:
+ * <OL>
+ * <LI>If <CODE>b1</CODE> and <CODE>b2</CODE> are both TRUE or
+ * neither <CODE>b1</CODE> nor <CODE>b2</CODE> is TRUE,
+ * return <CODE>true</CODE>.
+ * <LI>Otherwise, return <CODE>false</CODE>.
+ * </OL>
+ * <p/>
+ */
+ public static final boolean areBooleansEqual(Boolean b1, Boolean b2) {
+ // !jwetherb treat NULL the same as Boolean.FALSE
+ return (b1 == Boolean.TRUE && b2 == Boolean.TRUE) ||
+ (b1 != Boolean.TRUE && b2 != Boolean.TRUE);
+ }
+
+ /**
+ * This is a utility method that compares two objects when one or
+ * both of the objects might be <CODE>null</CODE>. The result
+ * returned by this method is determined as follows:
+ * <OL>
+ * <LI>If <CODE>o1</CODE> and <CODE>o2</CODE> are the same object
+ * according to the <CODE>==</CODE> operator, return
+ * <CODE>false</CODE>.
+ * <LI>Otherwise, if either <CODE>o1</CODE> or <CODE>o2</CODE> is
+ * <CODE>null</CODE>, return <CODE>true</CODE>.
+ * <LI>Otherwise, return <CODE>!o1.equals(o2)</CODE>.
+ * </OL>
+ * <p/>
+ * This method produces the exact logically inverted result as the
+ * {@link #areEqual(Object, Object)} method.<P>
+ * <p/>
+ * For array types, one of the <CODE>equals</CODE> methods in
+ * {@link java.util.Arrays} should be used instead of this method.
+ * Note that arrays with more than one dimension will require some
+ * custom code in order to implement <CODE>equals</CODE> properly.
+ */
+ public static final boolean areDifferent(Object o1, Object o2) {
+ return !areEqual(o1, o2);
+ }
+
+
+ /**
+ * This is a utility method that compares two Booleans when one or
+ * both of the objects might be <CODE>null</CODE> The result of
+ * this method is determined as follows:
+ * <OL>
+ * <LI>If <CODE>b1</CODE> and <CODE>b2</CODE> are both TRUE or
+ * neither <CODE>b1</CODE> nor <CODE>b2</CODE> is TRUE,
+ * return <CODE>false</CODE>.
+ * <LI>Otherwise, return <CODE>true</CODE>.
+ * </OL>
+ * <p/>
+ * This method produces the exact logically inverted result as the
+ * {@link #areBooleansEqual(Boolean, Boolean)} method.<P>
+ */
+ public static final boolean areBooleansDifferent(Boolean b1, Boolean b2) {
+ return !areBooleansEqual(b1, b2);
+ }
+
+
+ /**
+ * Returns <CODE>true</CODE> if the specified array is not null
+ * and contains a non-null element. Returns <CODE>false</CODE>
+ * if the array is null or if all the array elements are null.
+ */
+ public static final boolean hasNonNullElement(Object[] array) {
+ if (array != null) {
+ final int n = array.length;
+ for (int i = 0; i < n; i++) {
+ if (array[i] != null) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Returns a single string that is the concatenation of all the
+ * strings in the specified string array. A single space is
+ * put between each string array element. Null array elements
+ * are skipped. If the array itself is null, the empty string
+ * is returned. This method is guaranteed to return a non-null
+ * value, if no expections are thrown.
+ */
+ public static final String concat(String[] strs) {
+ return concat(strs, " "); //NOTRANS
+ }
+
+ /**
+ * Returns a single string that is the concatenation of all the
+ * strings in the specified string array. The strings are separated
+ * by the specified delimiter. Null array elements are skipped. If
+ * the array itself is null, the empty string is returned. This
+ * method is guaranteed to return a non-null value, if no expections
+ * are thrown.
+ */
+ public static final String concat(String[] strs, String delim) {
+ if (strs != null) {
+ final StringBuilder buf = new StringBuilder();
+ final int n = strs.length;
+ for (int i = 0; i < n; i++) {
+ final String str = strs[i];
+ if (str != null) {
+ buf.append(str).append(delim);
+ }
+ }
+ final int length = buf.length();
+ if (length > 0) {
+ // Trim trailing space.
+ buf.setLength(length - 1);
+ }
+ return buf.toString();
+ }
+ else {
+ return ""; // NOTRANS
+ }
+ }
+
+ /**
+ * Returns <CODE>true</CODE> if the specified {@link String} is not
+ * <CODE>null</CODE> and has a length greater than zero. This is
+ * a very frequently occurring check.
+ */
+ public static final boolean hasLength(String s) {
+ return (s != null && s.length() > 0);
+ }
+
+
+ /**
+ * Returns <CODE>null</CODE> if the specified string is empty or
+ * <CODE>null</CODE>. Otherwise the string itself is returned.
+ */
+ public static final String nullifyIfEmpty(String s) {
+ return ModelUtil.hasLength(s) ? s : null;
+ }
+
+ /**
+ * Returns <CODE>null</CODE> if the specified object is null
+ * or if its <CODE>toString()</CODE> representation is empty.
+ * Otherwise, the <CODE>toString()</CODE> representation of the
+ * object itself is returned.
+ */
+ public static final String nullifyingToString(Object o) {
+ return o != null ? nullifyIfEmpty(o.toString()) : null;
+ }
+
+ /**
+ * Determines if a string has been changed.
+ *
+ * @param oldString is the initial value of the String
+ * @param newString is the new value of the String
+ * @return true If both oldString and newString are null or if they are
+ * both not null and equal to each other. Otherwise returns false.
+ */
+ public static boolean hasStringChanged(String oldString, String newString) {
+ if (oldString == null && newString == null) {
+ return false;
+ }
+ else if ((oldString == null && newString != null)
+ || (oldString != null && newString == null)) {
+ return true;
+ }
+ else {
+ return !oldString.equals(newString);
+ }
+ }
+
+ public static String getTimeFromLong(long diff) {
+ final String HOURS = "h";
+ final String MINUTES = "min";
+ final String SECONDS = "sec";
+
+ final long MS_IN_A_DAY = 1000 * 60 * 60 * 24;
+ final long MS_IN_AN_HOUR = 1000 * 60 * 60;
+ final long MS_IN_A_MINUTE = 1000 * 60;
+ final long MS_IN_A_SECOND = 1000;
+ diff = diff % MS_IN_A_DAY;
+ long numHours = diff / MS_IN_AN_HOUR;
+ diff = diff % MS_IN_AN_HOUR;
+ long numMinutes = diff / MS_IN_A_MINUTE;
+ diff = diff % MS_IN_A_MINUTE;
+ long numSeconds = diff / MS_IN_A_SECOND;
+ diff = diff % MS_IN_A_SECOND;
+
+ StringBuilder buf = new StringBuilder();
+ if (numHours > 0) {
+ buf.append(numHours + " " + HOURS + ", ");
+ }
+
+ if (numMinutes > 0) {
+ buf.append(numMinutes + " " + MINUTES + ", ");
+ }
+
+ buf.append(numSeconds + " " + SECONDS);
+
+ String result = buf.toString();
+ return result;
+ }
+
+
+ /**
+ * Build a List of all elements in an Iterator.
+ */
+ public static <T> List<T> iteratorAsList(Iterator<T> i) {
+ ArrayList<T> list = new ArrayList<T>(10);
+ while (i.hasNext()) {
+ list.add(i.next());
+ }
+ return list;
+ }
+
+ /**
+ * Creates an Iterator that is the reverse of a ListIterator.
+ */
+ public static <T> Iterator<T> reverseListIterator(ListIterator<T> i) {
+ return new ReverseListIterator<T>(i);
+ }
+}
+
+/**
+ * An Iterator that is the reverse of a ListIterator.
+ */
+class ReverseListIterator<T> implements Iterator<T> {
+ private ListIterator<T> _i;
+
+ ReverseListIterator(ListIterator<T> i) {
+ _i = i;
+ while (_i.hasNext())
+ _i.next();
+ }
+
+ public boolean hasNext() {
+ return _i.hasPrevious();
+ }
+
+ public T next() {
+ return _i.previous();
+ }
+
+ public void remove() {
+ _i.remove();
+ }
+
+}
+
+
+
+
+
+
+
+
+
+
+
+ |