org.eclipse.jface.util.Util Maven / Gradle / Ivy
The newest version!
/******************************************************************************* * Copyright (c) 2000, 2015 IBM Corporation and others. * * This program and the accompanying materials * are made available under the terms of the Eclipse Public License 2.0 * which accompanies this distribution, and is available at * https://www.eclipse.org/legal/epl-2.0/ * * SPDX-License-Identifier: EPL-2.0 * * Contributors: * IBM Corporation - initial API and implementation *******************************************************************************/ package org.eclipse.jface.util; import java.util.Arrays; import java.util.Collections; import java.util.List; import java.util.MissingResourceException; import java.util.Objects; import java.util.ResourceBundle; import java.util.SortedSet; import java.util.TreeSet; import org.eclipse.swt.SWT; import org.eclipse.swt.graphics.Point; import org.eclipse.swt.graphics.Rectangle; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Monitor; import org.eclipse.swt.widgets.Widget; /** *
for windows platforms * @since 3.5 */ public static boolean isWindows() { final String ws = SWT.getPlatform(); return WS_WIN32.equals(ws) || WS_WPF.equals(ws); } /** * Common WS query helper method. * @return* A static class providing utility methods to all of JFace. *
* * @since 3.1 */ public final class Util { /** * An unmodifiable, empty, sorted set. This value is guaranteed to never * change and never benull
. */ public static final SortedSet EMPTY_SORTED_SET = Collections .unmodifiableSortedSet(new TreeSet<>()); /** * A common zero-length string. It avoids needing writeNON-NLS
* next to code fragments. It's also a bit clearer to read. */ public static final String ZERO_LENGTH_STRING = ""; //$NON-NLS-1$ /** * Verifies that the given object is an instance of the given class. * * @param object * The object to check; may benull
. * @param c * The class which the object should be; must not be *null
. */ public static void assertInstance(final Object object, final Class c) { assertInstance(object, c, false); } /** * Verifies the given object is an instance of the given class. It is * possible to specify whether the object is permitted to be *null
. * * @param object * The object to check; may benull
. * @param c * The class which the object should be; must not be *null
. * @param allowNull * Whether the object is allowed to benull
. */ private static void assertInstance(final Object object, final Class c, final boolean allowNull) { if (object == null && allowNull) { return; } if (object == null || c == null) { throw new NullPointerException(); } else if (!c.isInstance(object)) { throw new IllegalArgumentException(); } } /** * Compares two boolean values.false
is considered to be * "less than"true
. * * @param left * The left value to compare * @param right * The right value to compare * @return-1
if the left isfalse
and the * right istrue
.1
if the opposite * is true. If they are equal, then it returns0
. */ public static int compare(final boolean left, final boolean right) { return left == false ? (right == true ? -1 : 0) : 1; } /** * Compares two integer values. * * @param left * The left value to compare * @param right * The right value to compare * @returnleft - right
*/ public static int compare(final int left, final int right) { return left - right; } /** * Compares to comparable objects -- defending againstnull
. * * @param left * The left object to compare; may benull
. * @param right * The right object to compare; may benull
. * @return The result of the comparison.null
is considered * to be the least possible value. */ public static> int compare(final T left, final T right) { if (left == null && right == null) { return 0; } else if (left == null) { return -1; } else if (right == null) { return 1; } else { return left.compareTo(right); } } /** * Compares two arrays of comparable objects -- accounting for * null
. * * @param left * The left array to be compared; may benull
. * @param right * The right array to be compared; may benull
. * @return The result of the comparison.null
is considered * to be the least possible value. A shorter array is considered * less than a longer array. */ public static> int compare(final T[] left, final T[] right) { if (left == null && right == null) { return 0; } else if (left == null) { return -1; } else if (right == null) { return 1; } else { int l = left.length; int r = right.length; if (l != r) { return l - r; } for (int i = 0; i < l; i++) { int compareTo = compare(left[i], right[i]); if (compareTo != 0) { return compareTo; } } return 0; } } /** * Compares two lists -- account for null
. The lists must * contain comparable objects. * * @param left * The left list to compare; may benull
. This * list must only contain instances ofComparable
. * @param right * The right list to compare; may benull
. This * list must only contain instances ofComparable
. * @return The result of the comparison.null
is considered * to be the least possible value. A shorter list is considered less * than a longer list. */ public static> int compare(final List left, final List right) { if (left == null && right == null) { return 0; } else if (left == null) { return -1; } else if (right == null) { return 1; } else { int l = left.size(); int r = right.size(); if (l != r) { return l - r; } for (int i = 0; i < l; i++) { int compareTo = compare(left.get(i), right.get(i)); if (compareTo != 0) { return compareTo; } } return 0; } } /** * Tests whether the first array ends with the second array. * * @param left * The array to check (larger); may be null
. * @param right * The array that should be a subsequence (smaller); may be *null
. * @param equals * Whether the two array are allowed to be equal. * @returntrue
if the second array is a subsequence of the * array list, and they share end elements. */ public static boolean endsWith(final Object[] left, final Object[] right, final boolean equals) { if (left == null || right == null) { return false; } int l = left.length; int r = right.length; if (r > l || !equals && r == l) { return false; } for (int i = 0; i < r; i++) { if (!Objects.equals(left[l - i - 1], right[r - i - 1])) { return false; } } return true; } /** * Checks whether the two objects arenull
-- allowing for *null
. * * @param left * The left object to compare; may benull
. * @param right * The right object to compare; may benull
. * @returntrue
if the two objects are equivalent; *false
otherwise. * @deprecated Use {@link Objects#equals(Object, Object)} */ @Deprecated public static boolean equals(final Object left, final Object right) { return Objects.equals(left, right); } /** * Tests whether two arrays of objects are equal to each other. The arrays must * not benull
, but their elements may benull
. * * @param leftArray * The left array to compare; may benull
, and may be * empty and may containnull
elements. * @param rightArray * The right array to compare; may benull
, and may be * empty and may containnull
elements. * @returntrue
if the arrays are equal length and the elements at * the same position are equal;false
otherwise. * @deprecated Use {@link Arrays#equals(Object[], Object[])} */ @Deprecated public static boolean equals(final Object[] leftArray, final Object[] rightArray) { return Arrays.equals(leftArray, rightArray); } /** * Provides a hash code based on the given integer value. * * @param i The integer value * @returni
* @deprecated return directly value, or use {@link Integer#hashCode(int)} */ @Deprecated public static int hashCode(final int i) { return i; } /** * Provides a hash code for the object -- defending againstnull
. * * @param object The object for which a hash code is required. * @returnobject.hashCode
or0
ifobject
* ifnull
. * @deprecated use {@link Objects#hashCode(Object)} */ @Deprecated public static int hashCode(final Object object) { return object != null ? object.hashCode() : 0; } /** * Computes the hash code for an array of objects, but with defense against *null
. * * @param objects The array of objects for which a hash code is needed; may be *null
. * @return The hash code forobjects
; or0
if *objects
isnull
. * @deprecated use {@link Arrays#hashCode(Object[])} */ @Deprecated public static int hashCode(final Object[] objects) { if (objects == null) { return 0; } int hashCode = 89; for (final Object object : objects) { if (object != null) { hashCode = hashCode * 31 + object.hashCode(); } } return hashCode; } /** * Checks whether the second array is a subsequence of the first array, and * that they share common starting elements. * * @param left * The first array to compare (large); may benull
. * @param right * The second array to compare (small); may benull
. * @param equals * Whether it is allowed for the two arrays to be equivalent. * @returntrue
if the first arrays starts with the second * list;false
otherwise. */ public static boolean startsWith(final Object[] left, final Object[] right, final boolean equals) { if (left == null || right == null) { return false; } int l = left.length; int r = right.length; if (r > l || !equals && r == l) { return false; } for (int i = 0; i < r; i++) { if (!Objects.equals(left[i], right[i])) { return false; } } return true; } /** * Converts an array into a string representation that is suitable for * debugging. * * @param array * The array to convert; may benull
. * @return The string representation of the array; nevernull
. */ public static String toString(final Object[] array) { if (array == null) { return "null"; //$NON-NLS-1$ } final StringBuilder buffer = new StringBuilder(); buffer.append('['); final int length = array.length; for (int i = 0; i < length; i++) { if (i != 0) { buffer.append(','); } final Object object = array[i]; final String element = String.valueOf(object); buffer.append(element); } buffer.append(']'); return buffer.toString(); } /** * Provides a translation of a particular key from the resource bundle. * * @param resourceBundle * The key to look up in the resource bundle; should not be *null
. * @param key * The key to look up in the resource bundle; should not be *null
. * @param defaultString * The value to return if the resource cannot be found; may be *null
. * @return The value of the translated resource atkey
. If * the key cannot be found, then it is simply the *defaultString
. */ public static String translateString( final ResourceBundle resourceBundle, final String key, final String defaultString) { if (resourceBundle != null && key != null) { try { final String translatedString = resourceBundle.getString(key); if (translatedString != null) { return translatedString; } } catch (MissingResourceException eMissingResource) { // Such is life. We'll return the key } } return defaultString; } /** * Foundation replacement forString#replaceAll(String, * String)
, but without support for regular * expressions. * * @param src the original string * @param find the string to find * @param replacement the replacement string * @return the new string, with all occurrences offind
* replaced byreplacement
(not using regular * expressions) * @since 3.4 */ public static String replaceAll(String src, String find, String replacement) { final int len = src.length(); final int findLen = find.length(); int idx = src.indexOf(find); if (idx < 0) { return src; } StringBuilder buf = new StringBuilder(); int beginIndex = 0; while (idx != -1 && idx < len) { buf.append(src.substring(beginIndex, idx)); buf.append(replacement); beginIndex = idx + findLen; if (beginIndex < len) { idx = src.indexOf(find, beginIndex); } else { idx = -1; } } if (beginIndextrue true
for mac platforms * @since 3.5 */ public static boolean isMac() { final String ws = SWT.getPlatform(); return WS_CARBON.equals(ws) || WS_COCOA.equals(ws); } /** * Common WS query helper method. * @returntrue
for linux platform * @since 3.5 */ public static boolean isLinux() { final String ws = SWT.getPlatform(); return WS_GTK.equals(ws); } /** * Common WS query helper method. * @returntrue
for gtk platforms * @since 3.5 */ public static boolean isGtk() { final String ws = SWT.getPlatform(); return WS_GTK.equals(ws); } /** * Common WS query helper method. * @returntrue
for motif platforms * @since 3.5 */ @Deprecated public static boolean isMotif() { final String ws = SWT.getPlatform(); return WS_MOTIF.equals(ws); } /** * Common WS query helper method. * @returntrue
for photon platforms * @since 3.5 */ @Deprecated public static boolean isPhoton() { final String ws = SWT.getPlatform(); return WS_PHOTON.equals(ws); } /** * Common WS query helper method. * @returntrue
for carbon platforms * @since 3.5 */ @Deprecated public static boolean isCarbon() { final String ws = SWT.getPlatform(); return WS_CARBON.equals(ws); } /** * Common WS query helper method. * @returntrue
for the cocoa platform. * @since 3.5 */ public static boolean isCocoa() { final String ws = SWT.getPlatform(); return WS_COCOA.equals(ws); } /** * Common WS query helper method. * @returntrue
for WPF * @since 3.5 */ public static boolean isWpf() { final String ws = SWT.getPlatform(); return WS_WPF.equals(ws); } /** * Common WS query helper method. * @returntrue
for win32 * @since 3.5 */ public static boolean isWin32() { final String ws = SWT.getPlatform(); return WS_WIN32.equals(ws); } /** * Common WS query helper method. * @return the SWT windowing platform string. * @see SWT#getPlatform() * @since 3.5 */ public static String getWS() { return SWT.getPlatform(); } /** * This class should never be constructed. */ private Util() { // Not allowed. } /** * Returns the monitor whose client area contains the given point. If no monitor * contains the point, returns the monitor that is closest to the point. If this * is ever made public, it should be moved into a separate utility class. * * @param toSearch point to find (display coordinates) * @param toFind point to find (display coordinates) * @return the monitor closest to the given point * @since 3.15 */ public static Monitor getClosestMonitor(Display toSearch, Point toFind) { int closest = Integer.MAX_VALUE; Monitor[] monitors = toSearch.getMonitors(); Monitor result = monitors[0]; for (Monitor current : monitors) { Rectangle clientArea = current.getClientArea(); if (clientArea.contains(toFind)) { return current; } int distance = Geometry.distanceSquared(Geometry.centerPoint(clientArea), toFind); if (distance < closest) { closest = distance; result = current; } } return result; } /** * Helper method to check if a widget is not null and not disposed * * @param widget to be checked * @return true if widget is not disposed or null, false otherwise * @since 3.22 */ public static boolean isValid(Widget widget) { return widget != null && !widget.isDisposed(); } }