Java Code Examples for org.springframework.util.ClassUtils#determineCommonAncestor()

The following examples show how to use org.springframework.util.ClassUtils#determineCommonAncestor() . You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.

Example 1

Source File: Operator.java From spring-analysis-note with MIT License

4 votes

/**
 * Perform an equality check for the given operand values.
 * <p>This method is not just used for reflective comparisons in subclasses
 * but also from compiled expression code, which is why it needs to be
 * declared as {@code public static} here.
 * @param context the current evaluation context
 * @param left the left-hand operand value
 * @param right the right-hand operand value
 */
public static boolean equalityCheck(EvaluationContext context, @Nullable Object left, @Nullable Object right) {
	if (left instanceof Number && right instanceof Number) {
		Number leftNumber = (Number) left;
		Number rightNumber = (Number) right;

		if (leftNumber instanceof BigDecimal || rightNumber instanceof BigDecimal) {
			BigDecimal leftBigDecimal = NumberUtils.convertNumberToTargetClass(leftNumber, BigDecimal.class);
			BigDecimal rightBigDecimal = NumberUtils.convertNumberToTargetClass(rightNumber, BigDecimal.class);
			return (leftBigDecimal.compareTo(rightBigDecimal) == 0);
		}
		else if (leftNumber instanceof Double || rightNumber instanceof Double) {
			return (leftNumber.doubleValue() == rightNumber.doubleValue());
		}
		else if (leftNumber instanceof Float || rightNumber instanceof Float) {
			return (leftNumber.floatValue() == rightNumber.floatValue());
		}
		else if (leftNumber instanceof BigInteger || rightNumber instanceof BigInteger) {
			BigInteger leftBigInteger = NumberUtils.convertNumberToTargetClass(leftNumber, BigInteger.class);
			BigInteger rightBigInteger = NumberUtils.convertNumberToTargetClass(rightNumber, BigInteger.class);
			return (leftBigInteger.compareTo(rightBigInteger) == 0);
		}
		else if (leftNumber instanceof Long || rightNumber instanceof Long) {
			return (leftNumber.longValue() == rightNumber.longValue());
		}
		else if (leftNumber instanceof Integer || rightNumber instanceof Integer) {
			return (leftNumber.intValue() == rightNumber.intValue());
		}
		else if (leftNumber instanceof Short || rightNumber instanceof Short) {
			return (leftNumber.shortValue() == rightNumber.shortValue());
		}
		else if (leftNumber instanceof Byte || rightNumber instanceof Byte) {
			return (leftNumber.byteValue() == rightNumber.byteValue());
		}
		else {
			// Unknown Number subtypes -> best guess is double comparison
			return (leftNumber.doubleValue() == rightNumber.doubleValue());
		}
	}

	if (left instanceof CharSequence && right instanceof CharSequence) {
		return left.toString().equals(right.toString());
	}

	if (left instanceof Boolean && right instanceof Boolean) {
		return left.equals(right);
	}

	if (ObjectUtils.nullSafeEquals(left, right)) {
		return true;
	}

	if (left instanceof Comparable && right instanceof Comparable) {
		Class<?> ancestor = ClassUtils.determineCommonAncestor(left.getClass(), right.getClass());
		if (ancestor != null && Comparable.class.isAssignableFrom(ancestor)) {
			return (context.getTypeComparator().compare(left, right) == 0);
		}
	}

	return false;
}

Example 2

Source File: Operator.java From java-technology-stack with MIT License

4 votes

/**
 * Perform an equality check for the given operand values.
 * <p>This method is not just used for reflective comparisons in subclasses
 * but also from compiled expression code, which is why it needs to be
 * declared as {@code public static} here.
 * @param context the current evaluation context
 * @param left the left-hand operand value
 * @param right the right-hand operand value
 */
public static boolean equalityCheck(EvaluationContext context, @Nullable Object left, @Nullable Object right) {
	if (left instanceof Number && right instanceof Number) {
		Number leftNumber = (Number) left;
		Number rightNumber = (Number) right;

		if (leftNumber instanceof BigDecimal || rightNumber instanceof BigDecimal) {
			BigDecimal leftBigDecimal = NumberUtils.convertNumberToTargetClass(leftNumber, BigDecimal.class);
			BigDecimal rightBigDecimal = NumberUtils.convertNumberToTargetClass(rightNumber, BigDecimal.class);
			return (leftBigDecimal.compareTo(rightBigDecimal) == 0);
		}
		else if (leftNumber instanceof Double || rightNumber instanceof Double) {
			return (leftNumber.doubleValue() == rightNumber.doubleValue());
		}
		else if (leftNumber instanceof Float || rightNumber instanceof Float) {
			return (leftNumber.floatValue() == rightNumber.floatValue());
		}
		else if (leftNumber instanceof BigInteger || rightNumber instanceof BigInteger) {
			BigInteger leftBigInteger = NumberUtils.convertNumberToTargetClass(leftNumber, BigInteger.class);
			BigInteger rightBigInteger = NumberUtils.convertNumberToTargetClass(rightNumber, BigInteger.class);
			return (leftBigInteger.compareTo(rightBigInteger) == 0);
		}
		else if (leftNumber instanceof Long || rightNumber instanceof Long) {
			return (leftNumber.longValue() == rightNumber.longValue());
		}
		else if (leftNumber instanceof Integer || rightNumber instanceof Integer) {
			return (leftNumber.intValue() == rightNumber.intValue());
		}
		else if (leftNumber instanceof Short || rightNumber instanceof Short) {
			return (leftNumber.shortValue() == rightNumber.shortValue());
		}
		else if (leftNumber instanceof Byte || rightNumber instanceof Byte) {
			return (leftNumber.byteValue() == rightNumber.byteValue());
		}
		else {
			// Unknown Number subtypes -> best guess is double comparison
			return (leftNumber.doubleValue() == rightNumber.doubleValue());
		}
	}

	if (left instanceof CharSequence && right instanceof CharSequence) {
		return left.toString().equals(right.toString());
	}

	if (left instanceof Boolean && right instanceof Boolean) {
		return left.equals(right);
	}

	if (ObjectUtils.nullSafeEquals(left, right)) {
		return true;
	}

	if (left instanceof Comparable && right instanceof Comparable) {
		Class<?> ancestor = ClassUtils.determineCommonAncestor(left.getClass(), right.getClass());
		if (ancestor != null && Comparable.class.isAssignableFrom(ancestor)) {
			return (context.getTypeComparator().compare(left, right) == 0);
		}
	}

	return false;
}

Example 3

Source File: Operator.java From lams with GNU General Public License v2.0

4 votes

/**
 * Perform an equality check for the given operand values.
 * <p>This method is not just used for reflective comparisons in subclasses
 * but also from compiled expression code, which is why it needs to be
 * declared as {@code public static} here.
 * @param context the current evaluation context
 * @param left the left-hand operand value
 * @param right the right-hand operand value
 */
public static boolean equalityCheck(EvaluationContext context, Object left, Object right) {
	if (left instanceof Number && right instanceof Number) {
		Number leftNumber = (Number) left;
		Number rightNumber = (Number) right;

		if (leftNumber instanceof BigDecimal || rightNumber instanceof BigDecimal) {
			BigDecimal leftBigDecimal = NumberUtils.convertNumberToTargetClass(leftNumber, BigDecimal.class);
			BigDecimal rightBigDecimal = NumberUtils.convertNumberToTargetClass(rightNumber, BigDecimal.class);
			return (leftBigDecimal == null ? rightBigDecimal == null : leftBigDecimal.compareTo(rightBigDecimal) == 0);
		}
		else if (leftNumber instanceof Double || rightNumber instanceof Double) {
			return (leftNumber.doubleValue() == rightNumber.doubleValue());
		}
		else if (leftNumber instanceof Float || rightNumber instanceof Float) {
			return (leftNumber.floatValue() == rightNumber.floatValue());
		}
		else if (leftNumber instanceof BigInteger || rightNumber instanceof BigInteger) {
			BigInteger leftBigInteger = NumberUtils.convertNumberToTargetClass(leftNumber, BigInteger.class);
			BigInteger rightBigInteger = NumberUtils.convertNumberToTargetClass(rightNumber, BigInteger.class);
			return (leftBigInteger == null ? rightBigInteger == null : leftBigInteger.compareTo(rightBigInteger) == 0);
		}
		else if (leftNumber instanceof Long || rightNumber instanceof Long) {
			return (leftNumber.longValue() == rightNumber.longValue());
		}
		else if (leftNumber instanceof Integer || rightNumber instanceof Integer) {
			return (leftNumber.intValue() == rightNumber.intValue());
		}
		else if (leftNumber instanceof Short || rightNumber instanceof Short) {
			return (leftNumber.shortValue() == rightNumber.shortValue());
		}
		else if (leftNumber instanceof Byte || rightNumber instanceof Byte) {
			return (leftNumber.byteValue() == rightNumber.byteValue());
		}
		else {
			// Unknown Number subtypes -> best guess is double comparison
			return (leftNumber.doubleValue() == rightNumber.doubleValue());
		}
	}

	if (left instanceof CharSequence && right instanceof CharSequence) {
		return left.toString().equals(right.toString());
	}

	if (ObjectUtils.nullSafeEquals(left, right)) {
		return true;
	}

	if (left instanceof Comparable && right instanceof Comparable) {
		Class<?> ancestor = ClassUtils.determineCommonAncestor(left.getClass(), right.getClass());
		if (ancestor != null && Comparable.class.isAssignableFrom(ancestor)) {
			return (context.getTypeComparator().compare(left, right) == 0);
		}
	}

	return false;
}

Example 4

Source File: Operator.java From spring4-understanding with Apache License 2.0

4 votes

protected boolean equalityCheck(ExpressionState state, Object left, Object right) {
	if (left instanceof Number && right instanceof Number) {
		Number leftNumber = (Number) left;
		Number rightNumber = (Number) right;

		if (leftNumber instanceof BigDecimal || rightNumber instanceof BigDecimal) {
			BigDecimal leftBigDecimal = NumberUtils.convertNumberToTargetClass(leftNumber, BigDecimal.class);
			BigDecimal rightBigDecimal = NumberUtils.convertNumberToTargetClass(rightNumber, BigDecimal.class);
			return (leftBigDecimal == null ? rightBigDecimal == null : leftBigDecimal.compareTo(rightBigDecimal) == 0);
		}
		else if (leftNumber instanceof Double || rightNumber instanceof Double) {
			return (leftNumber.doubleValue() == rightNumber.doubleValue());
		}
		else if (leftNumber instanceof Float || rightNumber instanceof Float) {
			return (leftNumber.floatValue() == rightNumber.floatValue());
		}
		else if (leftNumber instanceof BigInteger || rightNumber instanceof BigInteger) {
			BigInteger leftBigInteger = NumberUtils.convertNumberToTargetClass(leftNumber, BigInteger.class);
			BigInteger rightBigInteger = NumberUtils.convertNumberToTargetClass(rightNumber, BigInteger.class);
			return (leftBigInteger == null ? rightBigInteger == null : leftBigInteger.compareTo(rightBigInteger) == 0);
		}
		else if (leftNumber instanceof Long || rightNumber instanceof Long) {
			return (leftNumber.longValue() == rightNumber.longValue());
		}
		else if (leftNumber instanceof Integer || rightNumber instanceof Integer) {
			return (leftNumber.intValue() == rightNumber.intValue());
		}
		else if (leftNumber instanceof Short || rightNumber instanceof Short) {
			return (leftNumber.shortValue() == rightNumber.shortValue());
		}
		else if (leftNumber instanceof Byte || rightNumber instanceof Byte) {
			return (leftNumber.byteValue() == rightNumber.byteValue());
		}
		else {
			// Unknown Number subtypes -> best guess is double comparison
			return (leftNumber.doubleValue() == rightNumber.doubleValue());
		}
	}

	if (left instanceof CharSequence && right instanceof CharSequence) {
		return left.toString().equals(right.toString());
	}

	if (ObjectUtils.nullSafeEquals(left, right)) {
		return true;
	}

	if (left instanceof Comparable && right instanceof Comparable) {
		Class<?> ancestor = ClassUtils.determineCommonAncestor(left.getClass(), right.getClass());
		if (ancestor != null && Comparable.class.isAssignableFrom(ancestor)) {
			return (state.getTypeComparator().compare(left, right) == 0);
		}
	}

	return false;
}