src/org/jivesoftware/smackx/workgroup/util/ModelUtil.java - platform/external/smack - Git at Google

 /**
  * 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();
     }

 }
	/**
	* 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();
	}

	}