org.eclipse.xtext.xbase.lib.Inline Java Examples

/** Convert the given value to {@code AtomicDouble}. This function is not null-safe.
 *
 * @param number a number of {@code AtomicInteger} type.
 * @return the equivalent value to {@code number} of {@code AtomicDouble} type.
 */
@Pure
@Inline(value = "new $2($1.doubleValue())", imported = AtomicDouble.class)
public static AtomicDouble toAtomicDouble(AtomicInteger number) {
	return new AtomicDouble(number.doubleValue());
}
 

/** Convert the given value to {@code AtomicLong}. This function is not null-safe.
 *
 * @param number a number of {@code Byte} type.
 * @return the equivalent value to {@code number} of {@code AtomicLong} type.
 */
@Pure
@Inline(value = "new $2($1.longValue())", imported = AtomicLong.class)
public static AtomicLong toAtomicLong(Number number) {
	return new AtomicLong(number.longValue());
}
 

/** Convert minutes to milliseconds.
 *
 * @param mins number of minutes to convert.
 * @return the number of milliseconds in <code>mins</code>
 */
@Pure
@Inline(value = "(long) (($1) * $2.MILLIS_IN_MINUTE)", imported = {TimeExtensions.class})
public static long minutes(double mins) {
	return (long) (mins * MILLIS_IN_MINUTE);
}
 

/** Convert the given value to {@code Integer}.
 *
 * @param number a number of {@code float} type.
 * @return the equivalent value to {@code number} of {@code Integer} type.
 */
@Pure
@Inline(value = "$2.valueOf(($3) $1)", imported = {Short.class, short.class})
public static Short toShort(float number) {
	return Short.valueOf((short) number);
}
 

/** Convert seconds to milliseconds.
 *
 * @param secs number of seconds to convert.
 * @return the number of milliseconds in seconds.
 */
@Pure
@Inline(value = "($1) * $2.MILLIS_IN_SECOND", imported = {TimeExtensions.class})
public static long seconds(long secs) {
	return secs * MILLIS_IN_SECOND;
}
 

/** Convert seconds to milliseconds.
 *
 * @param secs number of seconds to convert.
 * @return the number of milliseconds in seconds.
 */
@Pure
@Inline(value = "(long) (($1) * $2.MILLIS_IN_SECOND)", imported = {TimeExtensions.class})
public static long seconds(double secs) {
	return (long) (secs * MILLIS_IN_SECOND);
}
 

/** Convert milliseconds to milliseconds.
 *
 * @param milis number of milliseconds to convert.
 * @return the number of milliseconds in <code>milis</code>.
 */
@Pure
@Inline(value = "(long) ($1)")
public static long milliseconds(byte milis) {
	return milis;
}
 

/** Convert the given value to {@code Long}. This function is not null-safe.
 *
 * @param number a number of {@code AtomicLong} type.
 * @return the equivalent value to {@code number} of {@code Long} type.
 */
@Pure
@Inline(value = "$2.valueOf($1.longValue())", imported = Long.class)
public static Long toLong(AtomicLong number) {
	return number.longValue();
}
 

/** The binary {@code notEquals} operator. This is the equivalent
 * to the Java {@code !=} operator. This function is null-safe.
 *
 * @param left a number.
 * @param right a number.
 * @return {@code left!=right}
 */
@Pure
@Inline(value = "($1 == null || ($1.doubleValue() != $2))", constantExpression = true)
public static boolean operator_notEquals(Double left, double right) {
	return left != null && left.doubleValue() != right;
}
 

/** The binary {@code divide} operator. This is the equivalent to
 * the Java {@code /} operator. This function is not null-safe.
 *
 * @param left a number.
 * @param right a number.
 * @return {@code left/right}
 */
@Pure
@Inline(value = "($1 / $2.doubleValue())", constantExpression = true)
public static double operator_divide(long left, Number right) {
	return left / right.doubleValue();
}
 

/** The binary {@code lessEqualsThan} operator. This is the equivalent
 * to the Java {@code <=} operator. This function is not null-safe.
 *
 * @param left a number.
 * @param right a number.
 * @return {@code left<=right}
 */
@Pure
@Inline(value = "($1.shortValue() <= $2.doubleValue())", constantExpression = true)
public static boolean operator_lessEqualsThan(Short left, Number right) {
	return left.shortValue() <= right.doubleValue();
}
 

/**
 * The binary {@code equals} operator. This is the equivalent to the Java {@code ==} operator.
 * This function is null-safe.
 *
 * @param left a number.
 * @param right a number.
 * @return {@code left==right}
 */
@Pure
@Inline(value = "($2 != null && $1 == $2.doubleValue())", constantExpression = true)
public static boolean operator_equals(byte left, Number right) {
	return right != null && left == right.doubleValue();
}
 

/** The binary {@code divide} operator. This is the equivalent to
 * the Java {@code /} operator. This function is not null-safe.
 *
 * @param left a number.
 * @param right a number.
 * @return {@code left/right}
 */
@Pure
@Inline(value = "($1.shortValue() / $2)", constantExpression = true)
public static int operator_divide(Short left, byte right) {
	return left.shortValue() / right;
}
 

/** The binary {@code lessEqualsThan} operator. This is the equivalent
 * to the Java {@code <=} operator. This function is not null-safe.
 *
 * @param left a number.
 * @param right a number.
 * @return {@code left<=right}
 */
@Pure
@Inline(value = "($1.byteValue() <= $2)", constantExpression = true)
public static boolean operator_lessEqualsThan(Byte left, long right) {
	return left.byteValue() <= right;
}
 

/**
 * The binary {@code equals} operator. This is the equivalent to the Java {@code ==} operator.
 * This function is null-safe.
 *
 * @param left a number.
 * @param right a number.
 * @return {@code left==right}
 */
@Pure
@Inline(value = "($1 != null ? ($1.longValue() == $2) : false)", constantExpression = true)
public static boolean operator_equals(AtomicInteger left, long right) {
	return left != null ? left.longValue() == right : false;
}
 

/** The number comparison operator. This is equivalent to the Java
 * {@code compareTo} function on numbers. This function is null-safe.
 *
 * @param left a number
 * @param right a number.
 * @return the value {@code 0} if {@code left == right};
    *         a value less than {@code 0} if {@code left < right}; and
    *         a value greater than {@code 0} if {@code left > right}.
 */
@Pure
@Inline(value = "$3.compare($1.intValue(), $2)", constantExpression = true, imported = Float.class)
public static int operator_spaceship(Integer left, float right) {
	return Float.compare(left.intValue(),  right);
}
 

/** The binary {@code minus} operator. This is the equivalent to
 * the Java {@code -} operator. This function is not null-safe.
 *
 * @param left a number.
 * @param right a number.
 * @return {@code left-right}
 */
@Pure
@Inline(value = "($1.shortValue() - $2)", constantExpression = true)
public static int operator_minus(Short left, short right) {
	return left.shortValue() - right;
}
 

/** The binary {@code modulo} operator. This is the equivalent to
 * the Java {@code %} operator. This function is not null-safe.
 *
 * @param left a number.
 * @param right a number.
 * @return {@code left%right}
 */
@Pure
@Inline(value = "($1.intValue() % $2)", constantExpression = true)
public static double operator_modulo(Integer left, double right) {
	return left.intValue() % right;
}
 

/** The binary {@code lessEqualsThan} operator. This is the equivalent
 * to the Java {@code <=} operator. This function is not null-safe.
 *
 * @param left a number.
 * @param right a number.
 * @return {@code left<=right}
 */
@Pure
@Inline(value = "($1.doubleValue() <= $2)", constantExpression = true)
public static boolean operator_lessEqualsThan(Number left, byte right) {
	return left.doubleValue() <= right;
}
 

/** The binary {@code modulo} operator. This is the equivalent to
 * the Java {@code %} operator. This function is not null-safe.
 *
 * @param left a number.
 * @param right a number.
 * @return {@code left%right}
 */
@Pure
@Inline(value = "($1.byteValue() % $2)", constantExpression = true)
public static int operator_modulo(Byte left, short right) {
	return left.byteValue() % right;
}
 

/** The binary {@code greaterEqualsThan} operator. This is the equivalent
 * to the Java {@code >=} operator. This function is not null-safe.
 *
 * @param left a number.
 * @param right a number.
 * @return {@code left>=right}
 */
@Pure
@Inline(value = "($1.floatValue() >= $2)", constantExpression = true)
public static boolean operator_greaterEqualsThan(Float left, float right) {
	return left.floatValue() >= right;
}
 

/** The binary {@code greaterEqualsThan} operator. This is the equivalent
 * to the Java {@code >=} operator. This function is not null-safe.
 *
 * @param left a number.
 * @param right a number.
 * @return {@code left>=right}
 */
@Pure
@Inline(value = "($1.byteValue() >= $2)", constantExpression = true)
public static boolean operator_greaterEqualsThan(Byte left, byte right) {
	return left.byteValue() >= right;
}
 

/** The binary {@code modulo} operator. This is the equivalent to
 * the Java {@code %} operator. This function is not null-safe.
 *
 * @param left a number.
 * @param right a number.
 * @return {@code left%right}
 */
@Pure
@Inline(value = "($1 % $2.doubleValue())", constantExpression = true)
public static double operator_modulo(byte left, Number right) {
	return left % right.doubleValue();
}
 

/** The binary {@code minus} operator. This is the equivalent to
 * the Java {@code -} operator. This function is not null-safe.
 *
 * @param left a number.
 * @param right a number.
 * @return {@code left-right}
 */
@Pure
@Inline(value = "($1.byteValue() - $2.longValue())", constantExpression = true)
public static long operator_minus(Byte left, Long right) {
	return left.byteValue() - right.longValue();
}
 

/** The binary {@code greaterThan} operator. This is the equivalent
 * to the Java {@code >} operator. This function is not null-safe.
 *
 * @param left a number.
 * @param right a number.
 * @return {@code left>right}
 */
@Pure
@Inline(value = "($1.longValue() > $2)", constantExpression = true)
public static boolean operator_greaterThan(AtomicLong left, long right) {
	return left.longValue() > right;
}
 

/** The binary {@code plus} operator. This is the equivalent to
 * the Java {@code +} operator. This function is not null-safe.
 *
 * @param left a number.
 * @param right a number.
 * @return {@code left+right}
 */
@Pure
@Inline(value = "($1 + $2.doubleValue())", constantExpression = true)
public static double operator_plus(long left, Number right) {
	return left + right.doubleValue();
}
 

/** The number comparison operator. This is equivalent to the Java
 * {@code compareTo} function on numbers. This function is null-safe.
 *
 * @param left a number
 * @param right a number.
 * @return the value {@code 0} if {@code left == right};
    *         a value less than {@code 0} if {@code left < right}; and
    *         a value greater than {@code 0} if {@code left > right}.
 */
@Pure
@Inline(value = "$3.compare($1, $2.doubleValue())", constantExpression = true, imported = Double.class)
public static int operator_spaceship(int left, Double right) {
	return Double.compare(left,  right.doubleValue());
}
 

/** The number comparison operator. This is equivalent to the Java
 * {@code compareTo} function on numbers. This function is null-safe.
 *
 * @param left a number
 * @param right a number.
 * @return the value {@code 0} if {@code left == right};
    *         a value less than {@code 0} if {@code left < right}; and
    *         a value greater than {@code 0} if {@code left > right}.
 */
@Pure
@Inline(value = "$3.compare($1, $2.intValue())", constantExpression = true, imported = Integer.class)
public static int operator_spaceship(short left, AtomicInteger right) {
	return Integer.compare(left,  right.intValue());
}
 

/** The number comparison operator. This is equivalent to the Java
 * {@code compareTo} function on numbers. This function is null-safe.
 *
 * @param left a number
 * @param right a number.
 * @return the value {@code 0} if {@code left == right};
    *         a value less than {@code 0} if {@code left < right}; and
    *         a value greater than {@code 0} if {@code left > right}.
 */
@Pure
@Inline(value = "$3.compare($1.longValue(), $2)", constantExpression = true, imported = Long.class)
public static int operator_spaceship(Long left, short right) {
	return Long.compare(left.longValue(),  right);
}
 

/** The binary {@code greaterThan} operator. This is the equivalent
 * to the Java {@code >} operator. This function is not null-safe.
 *
 * @param left a number.
 * @param right a number.
 * @return {@code left>right}
 */
@Pure
@Inline(value = "($1.floatValue() > $2)", constantExpression = true)
public static boolean operator_greaterThan(Float left, short right) {
	return left.floatValue() > right;
}