blob: 270d5622cafddcfa8d8acc7026017847c95afbb5 [file] [log] [blame]
/*******************************************************************************
* Copyright (c) 2012 itemis AG (http://www.itemis.eu) and others.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* SPDX-License-Identifier: EPL-2.0
*******************************************************************************/
package org.eclipse.xtext.xbase.lib;
import com.google.common.annotations.GwtCompatible;
/**
* This is an extension library for {@link Short} numbers.
*
* @author Jan Koehnlein - Code generator
* @since 2.3
*/
@GwtCompatible public class ShortExtensions {
// BEGIN generated code
/**
* The unary <code>minus</code> operator. This is the equivalent to the Java's <code>-</code> function.
*
* @param s a short.
* @return <code>-s</code>
* @since 2.3
*/
@Pure
@Inline(value="(-$1)", constantExpression=true)
public static int operator_minus(short s) {
return -s;
}
/**
* The postfix <code>decrement</code> operator. This is the equivalent to the Java's <code>--</code> postfix function.
*
* @param s a short.
* @return <code>s--</code>
* @since 2.6
*/
@Inline(value="$1--")
public static short operator_minusMinus(short s) {
throw new HardcodedInInterpreterException();
}
/**
* The postfix <code>decrement</code> operator. This is the equivalent to the Java's <code>--</code> postfix function.
*
* @param s a short.
* @return <code>s--</code>
* @since 2.6
*/
@Inline(value="$1--")
public static Short operator_minusMinus(Short s) {
throw new HardcodedInInterpreterException();
}
/**
* The postfix <code>increment</code> operator. This is the equivalent to the Java's <code>++</code> postfix function.
*
* @param s a short.
* @return <code>s++</code>
* @since 2.6
*/
@Inline(value="$1++")
public static short operator_plusPlus(short s) {
throw new HardcodedInInterpreterException();
}
/**
* The postfix <code>increment</code> operator. This is the equivalent to the Java's <code>++</code> postfix function.
*
* @param s a short.
* @return <code>s++</code>
* @since 2.6
*/
@Inline(value="$1++")
public static Short operator_plusPlus(Short s) {
throw new HardcodedInInterpreterException();
}
/**
* The binary <code>plus</code> operator. This is the equivalent to the Java <code>+</code> operator.
*
* @param a a short.
* @param b a double.
* @return <code>a+b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 + $2)", constantExpression=true)
public static double operator_plus(short a, double b) {
return a + b;
}
/**
* The binary <code>minus</code> operator. This is the equivalent to the Java <code>-</code> operator.
*
* @param a a short.
* @param b a double.
* @return <code>a-b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 - $2)", constantExpression=true)
public static double operator_minus(short a, double b) {
return a - b;
}
/**
* The binary <code>multiply</code> operator. This is the equivalent to the Java <code>*</code> operator.
*
* @param a a short.
* @param b a double.
* @return <code>a*b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 * $2)", constantExpression=true)
public static double operator_multiply(short a, double b) {
return a * b;
}
/**
* The binary <code>divide</code> operator. This is the equivalent to the Java <code>/</code> operator.
*
* @param a a short.
* @param b a double.
* @return <code>a/b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 / $2)", constantExpression=true)
public static double operator_divide(short a, double b) {
return a / b;
}
/**
* The binary <code>modulo</code> operator. This is the equivalent to the Java <code>%</code> operator.
*
* @param a a short.
* @param b a double.
* @return <code>a%b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 % $2)", constantExpression=true)
public static double operator_modulo(short a, double b) {
return a % b;
}
/**
* The binary <code>lessThan</code> operator. This is the equivalent to the Java <code>&lt;</code> operator.
*
* @param a a short.
* @param b a double.
* @return <code>a&lt;b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 < $2)", constantExpression=true)
public static boolean operator_lessThan(short a, double b) {
return a < b;
}
/**
* The binary <code>lessEqualsThan</code> operator. This is the equivalent to the Java <code>&lt;=</code> operator.
*
* @param a a short.
* @param b a double.
* @return <code>a&lt;=b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 <= $2)", constantExpression=true)
public static boolean operator_lessEqualsThan(short a, double b) {
return a <= b;
}
/**
* The binary <code>greaterThan</code> operator. This is the equivalent to the Java <code>&gt;</code> operator.
*
* @param a a short.
* @param b a double.
* @return <code>a&gt;b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 > $2)", constantExpression=true)
public static boolean operator_greaterThan(short a, double b) {
return a > b;
}
/**
* The binary <code>greaterEqualsThan</code> operator. This is the equivalent to the Java <code>&gt;=</code> operator.
*
* @param a a short.
* @param b a double.
* @return <code>a&gt;=b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 >= $2)", constantExpression=true)
public static boolean operator_greaterEqualsThan(short a, double b) {
return a >= b;
}
/**
* The binary <code>equals</code> operator. This is the equivalent to the Java <code>==</code> operator.
*
* @param a a short.
* @param b a double.
* @return <code>a==b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 == $2)", constantExpression=true)
public static boolean operator_equals(short a, double b) {
return a == b;
}
/**
* The binary <code>notEquals</code> operator. This is the equivalent to the Java <code>!=</code> operator.
*
* @param a a short.
* @param b a double.
* @return <code>a!=b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 != $2)", constantExpression=true)
public static boolean operator_notEquals(short a, double b) {
return a != b;
}
/**
* The binary <code>power</code> operator. This is the equivalent to the Java's <code>Math.pow()</code> function.
*
* @param a a short.
* @param b a double.
* @return <code>Math.pow(a, b)</code>
* @since 2.3
*/
@Pure
@Inline(value="$3.pow($1, $2)", imported=Math.class)
public static double operator_power(short a, double b) {
return Math.pow(a, b);
}
/**
* The <code>identity equals</code> operator. This is the equivalent to Java's <code>==</code>
* operator.
*
* @param a a short.
* @param b a double.
* @return <code>a == b</code>
* @since 2.4
*/
@Pure
@Inline(value="($1 == $2)", constantExpression=true)
public static boolean operator_tripleEquals(short a, double b) {
return a == b;
}
/**
* The <code>identity not equals</code> operator. This is the equivalent to Java's <code>!=</code>
* operator.
*
* @param a a short.
* @param b a double.
* @return <code>a != b</code>
* @since 2.4
*/
@Pure
@Inline(value="($1 != $2)", constantExpression=true)
public static boolean operator_tripleNotEquals(short a, double b) {
return a != b;
}
/**
* The binary <code>plus</code> operator. This is the equivalent to the Java <code>+</code> operator.
*
* @param a a short.
* @param b a float.
* @return <code>a+b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 + $2)", constantExpression=true)
public static float operator_plus(short a, float b) {
return a + b;
}
/**
* The binary <code>minus</code> operator. This is the equivalent to the Java <code>-</code> operator.
*
* @param a a short.
* @param b a float.
* @return <code>a-b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 - $2)", constantExpression=true)
public static float operator_minus(short a, float b) {
return a - b;
}
/**
* The binary <code>multiply</code> operator. This is the equivalent to the Java <code>*</code> operator.
*
* @param a a short.
* @param b a float.
* @return <code>a*b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 * $2)", constantExpression=true)
public static float operator_multiply(short a, float b) {
return a * b;
}
/**
* The binary <code>divide</code> operator. This is the equivalent to the Java <code>/</code> operator.
*
* @param a a short.
* @param b a float.
* @return <code>a/b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 / $2)", constantExpression=true)
public static float operator_divide(short a, float b) {
return a / b;
}
/**
* The binary <code>modulo</code> operator. This is the equivalent to the Java <code>%</code> operator.
*
* @param a a short.
* @param b a float.
* @return <code>a%b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 % $2)", constantExpression=true)
public static float operator_modulo(short a, float b) {
return a % b;
}
/**
* The binary <code>lessThan</code> operator. This is the equivalent to the Java <code>&lt;</code> operator.
*
* @param a a short.
* @param b a float.
* @return <code>a&lt;b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 < $2)", constantExpression=true)
public static boolean operator_lessThan(short a, float b) {
return a < b;
}
/**
* The binary <code>lessEqualsThan</code> operator. This is the equivalent to the Java <code>&lt;=</code> operator.
*
* @param a a short.
* @param b a float.
* @return <code>a&lt;=b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 <= $2)", constantExpression=true)
public static boolean operator_lessEqualsThan(short a, float b) {
return a <= b;
}
/**
* The binary <code>greaterThan</code> operator. This is the equivalent to the Java <code>&gt;</code> operator.
*
* @param a a short.
* @param b a float.
* @return <code>a&gt;b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 > $2)", constantExpression=true)
public static boolean operator_greaterThan(short a, float b) {
return a > b;
}
/**
* The binary <code>greaterEqualsThan</code> operator. This is the equivalent to the Java <code>&gt;=</code> operator.
*
* @param a a short.
* @param b a float.
* @return <code>a&gt;=b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 >= $2)", constantExpression=true)
public static boolean operator_greaterEqualsThan(short a, float b) {
return a >= b;
}
/**
* The binary <code>equals</code> operator. This is the equivalent to the Java <code>==</code> operator.
*
* @param a a short.
* @param b a float.
* @return <code>a==b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 == $2)", constantExpression=true)
public static boolean operator_equals(short a, float b) {
return a == b;
}
/**
* The binary <code>notEquals</code> operator. This is the equivalent to the Java <code>!=</code> operator.
*
* @param a a short.
* @param b a float.
* @return <code>a!=b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 != $2)", constantExpression=true)
public static boolean operator_notEquals(short a, float b) {
return a != b;
}
/**
* The binary <code>power</code> operator. This is the equivalent to the Java's <code>Math.pow()</code> function.
*
* @param a a short.
* @param b a float.
* @return <code>Math.pow(a, b)</code>
* @since 2.3
*/
@Pure
@Inline(value="$3.pow($1, $2)", imported=Math.class)
public static double operator_power(short a, float b) {
return Math.pow(a, b);
}
/**
* The <code>identity equals</code> operator. This is the equivalent to Java's <code>==</code>
* operator.
*
* @param a a short.
* @param b a float.
* @return <code>a == b</code>
* @since 2.4
*/
@Pure
@Inline(value="($1 == $2)", constantExpression=true)
public static boolean operator_tripleEquals(short a, float b) {
return a == b;
}
/**
* The <code>identity not equals</code> operator. This is the equivalent to Java's <code>!=</code>
* operator.
*
* @param a a short.
* @param b a float.
* @return <code>a != b</code>
* @since 2.4
*/
@Pure
@Inline(value="($1 != $2)", constantExpression=true)
public static boolean operator_tripleNotEquals(short a, float b) {
return a != b;
}
/**
* The binary <code>plus</code> operator. This is the equivalent to the Java <code>+</code> operator.
*
* @param a a short.
* @param b a long.
* @return <code>a+b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 + $2)", constantExpression=true)
public static long operator_plus(short a, long b) {
return a + b;
}
/**
* The binary <code>minus</code> operator. This is the equivalent to the Java <code>-</code> operator.
*
* @param a a short.
* @param b a long.
* @return <code>a-b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 - $2)", constantExpression=true)
public static long operator_minus(short a, long b) {
return a - b;
}
/**
* The binary <code>multiply</code> operator. This is the equivalent to the Java <code>*</code> operator.
*
* @param a a short.
* @param b a long.
* @return <code>a*b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 * $2)", constantExpression=true)
public static long operator_multiply(short a, long b) {
return a * b;
}
/**
* The binary <code>divide</code> operator. This is the equivalent to the Java <code>/</code> operator.
*
* @param a a short.
* @param b a long.
* @return <code>a/b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 / $2)", constantExpression=true)
public static long operator_divide(short a, long b) {
return a / b;
}
/**
* The binary <code>modulo</code> operator. This is the equivalent to the Java <code>%</code> operator.
*
* @param a a short.
* @param b a long.
* @return <code>a%b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 % $2)", constantExpression=true)
public static long operator_modulo(short a, long b) {
return a % b;
}
/**
* The binary <code>lessThan</code> operator. This is the equivalent to the Java <code>&lt;</code> operator.
*
* @param a a short.
* @param b a long.
* @return <code>a&lt;b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 < $2)", constantExpression=true)
public static boolean operator_lessThan(short a, long b) {
return a < b;
}
/**
* The binary <code>lessEqualsThan</code> operator. This is the equivalent to the Java <code>&lt;=</code> operator.
*
* @param a a short.
* @param b a long.
* @return <code>a&lt;=b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 <= $2)", constantExpression=true)
public static boolean operator_lessEqualsThan(short a, long b) {
return a <= b;
}
/**
* The binary <code>greaterThan</code> operator. This is the equivalent to the Java <code>&gt;</code> operator.
*
* @param a a short.
* @param b a long.
* @return <code>a&gt;b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 > $2)", constantExpression=true)
public static boolean operator_greaterThan(short a, long b) {
return a > b;
}
/**
* The binary <code>greaterEqualsThan</code> operator. This is the equivalent to the Java <code>&gt;=</code> operator.
*
* @param a a short.
* @param b a long.
* @return <code>a&gt;=b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 >= $2)", constantExpression=true)
public static boolean operator_greaterEqualsThan(short a, long b) {
return a >= b;
}
/**
* The binary <code>equals</code> operator. This is the equivalent to the Java <code>==</code> operator.
*
* @param a a short.
* @param b a long.
* @return <code>a==b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 == $2)", constantExpression=true)
public static boolean operator_equals(short a, long b) {
return a == b;
}
/**
* The binary <code>notEquals</code> operator. This is the equivalent to the Java <code>!=</code> operator.
*
* @param a a short.
* @param b a long.
* @return <code>a!=b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 != $2)", constantExpression=true)
public static boolean operator_notEquals(short a, long b) {
return a != b;
}
/**
* The binary <code>power</code> operator. This is the equivalent to the Java's <code>Math.pow()</code> function.
*
* @param a a short.
* @param b a long.
* @return <code>Math.pow(a, b)</code>
* @since 2.3
*/
@Pure
@Inline(value="$3.pow($1, $2)", imported=Math.class)
public static double operator_power(short a, long b) {
return Math.pow(a, b);
}
/**
* The <code>identity equals</code> operator. This is the equivalent to Java's <code>==</code>
* operator.
*
* @param a a short.
* @param b a long.
* @return <code>a == b</code>
* @since 2.4
*/
@Pure
@Inline(value="($1 == $2)", constantExpression=true)
public static boolean operator_tripleEquals(short a, long b) {
return a == b;
}
/**
* The <code>identity not equals</code> operator. This is the equivalent to Java's <code>!=</code>
* operator.
*
* @param a a short.
* @param b a long.
* @return <code>a != b</code>
* @since 2.4
*/
@Pure
@Inline(value="($1 != $2)", constantExpression=true)
public static boolean operator_tripleNotEquals(short a, long b) {
return a != b;
}
/**
* The binary <code>plus</code> operator. This is the equivalent to the Java <code>+</code> operator.
*
* @param a a short.
* @param b an integer.
* @return <code>a+b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 + $2)", constantExpression=true)
public static int operator_plus(short a, int b) {
return a + b;
}
/**
* The binary <code>minus</code> operator. This is the equivalent to the Java <code>-</code> operator.
*
* @param a a short.
* @param b an integer.
* @return <code>a-b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 - $2)", constantExpression=true)
public static int operator_minus(short a, int b) {
return a - b;
}
/**
* The binary <code>multiply</code> operator. This is the equivalent to the Java <code>*</code> operator.
*
* @param a a short.
* @param b an integer.
* @return <code>a*b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 * $2)", constantExpression=true)
public static int operator_multiply(short a, int b) {
return a * b;
}
/**
* The binary <code>divide</code> operator. This is the equivalent to the Java <code>/</code> operator.
*
* @param a a short.
* @param b an integer.
* @return <code>a/b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 / $2)", constantExpression=true)
public static int operator_divide(short a, int b) {
return a / b;
}
/**
* The binary <code>modulo</code> operator. This is the equivalent to the Java <code>%</code> operator.
*
* @param a a short.
* @param b an integer.
* @return <code>a%b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 % $2)", constantExpression=true)
public static int operator_modulo(short a, int b) {
return a % b;
}
/**
* The binary <code>lessThan</code> operator. This is the equivalent to the Java <code>&lt;</code> operator.
*
* @param a a short.
* @param b an integer.
* @return <code>a&lt;b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 < $2)", constantExpression=true)
public static boolean operator_lessThan(short a, int b) {
return a < b;
}
/**
* The binary <code>lessEqualsThan</code> operator. This is the equivalent to the Java <code>&lt;=</code> operator.
*
* @param a a short.
* @param b an integer.
* @return <code>a&lt;=b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 <= $2)", constantExpression=true)
public static boolean operator_lessEqualsThan(short a, int b) {
return a <= b;
}
/**
* The binary <code>greaterThan</code> operator. This is the equivalent to the Java <code>&gt;</code> operator.
*
* @param a a short.
* @param b an integer.
* @return <code>a&gt;b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 > $2)", constantExpression=true)
public static boolean operator_greaterThan(short a, int b) {
return a > b;
}
/**
* The binary <code>greaterEqualsThan</code> operator. This is the equivalent to the Java <code>&gt;=</code> operator.
*
* @param a a short.
* @param b an integer.
* @return <code>a&gt;=b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 >= $2)", constantExpression=true)
public static boolean operator_greaterEqualsThan(short a, int b) {
return a >= b;
}
/**
* The binary <code>equals</code> operator. This is the equivalent to the Java <code>==</code> operator.
*
* @param a a short.
* @param b an integer.
* @return <code>a==b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 == $2)", constantExpression=true)
public static boolean operator_equals(short a, int b) {
return a == b;
}
/**
* The binary <code>notEquals</code> operator. This is the equivalent to the Java <code>!=</code> operator.
*
* @param a a short.
* @param b an integer.
* @return <code>a!=b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 != $2)", constantExpression=true)
public static boolean operator_notEquals(short a, int b) {
return a != b;
}
/**
* The binary <code>power</code> operator. This is the equivalent to the Java's <code>Math.pow()</code> function.
*
* @param a a short.
* @param b an integer.
* @return <code>Math.pow(a, b)</code>
* @since 2.3
*/
@Pure
@Inline(value="$3.pow($1, $2)", imported=Math.class)
public static double operator_power(short a, int b) {
return Math.pow(a, b);
}
/**
* The <code>identity equals</code> operator. This is the equivalent to Java's <code>==</code>
* operator.
*
* @param a a short.
* @param b an integer.
* @return <code>a == b</code>
* @since 2.4
*/
@Pure
@Inline(value="($1 == $2)", constantExpression=true)
public static boolean operator_tripleEquals(short a, int b) {
return a == b;
}
/**
* The <code>identity not equals</code> operator. This is the equivalent to Java's <code>!=</code>
* operator.
*
* @param a a short.
* @param b an integer.
* @return <code>a != b</code>
* @since 2.4
*/
@Pure
@Inline(value="($1 != $2)", constantExpression=true)
public static boolean operator_tripleNotEquals(short a, int b) {
return a != b;
}
/**
* The binary <code>plus</code> operator. This is the equivalent to the Java <code>+</code> operator.
*
* @param a a short.
* @param b a character.
* @return <code>a+b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 + $2)", constantExpression=true)
public static int operator_plus(short a, char b) {
return a + b;
}
/**
* The binary <code>minus</code> operator. This is the equivalent to the Java <code>-</code> operator.
*
* @param a a short.
* @param b a character.
* @return <code>a-b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 - $2)", constantExpression=true)
public static int operator_minus(short a, char b) {
return a - b;
}
/**
* The binary <code>multiply</code> operator. This is the equivalent to the Java <code>*</code> operator.
*
* @param a a short.
* @param b a character.
* @return <code>a*b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 * $2)", constantExpression=true)
public static int operator_multiply(short a, char b) {
return a * b;
}
/**
* The binary <code>divide</code> operator. This is the equivalent to the Java <code>/</code> operator.
*
* @param a a short.
* @param b a character.
* @return <code>a/b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 / $2)", constantExpression=true)
public static int operator_divide(short a, char b) {
return a / b;
}
/**
* The binary <code>modulo</code> operator. This is the equivalent to the Java <code>%</code> operator.
*
* @param a a short.
* @param b a character.
* @return <code>a%b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 % $2)", constantExpression=true)
public static int operator_modulo(short a, char b) {
return a % b;
}
/**
* The binary <code>lessThan</code> operator. This is the equivalent to the Java <code>&lt;</code> operator.
*
* @param a a short.
* @param b a character.
* @return <code>a&lt;b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 < $2)", constantExpression=true)
public static boolean operator_lessThan(short a, char b) {
return a < b;
}
/**
* The binary <code>lessEqualsThan</code> operator. This is the equivalent to the Java <code>&lt;=</code> operator.
*
* @param a a short.
* @param b a character.
* @return <code>a&lt;=b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 <= $2)", constantExpression=true)
public static boolean operator_lessEqualsThan(short a, char b) {
return a <= b;
}
/**
* The binary <code>greaterThan</code> operator. This is the equivalent to the Java <code>&gt;</code> operator.
*
* @param a a short.
* @param b a character.
* @return <code>a&gt;b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 > $2)", constantExpression=true)
public static boolean operator_greaterThan(short a, char b) {
return a > b;
}
/**
* The binary <code>greaterEqualsThan</code> operator. This is the equivalent to the Java <code>&gt;=</code> operator.
*
* @param a a short.
* @param b a character.
* @return <code>a&gt;=b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 >= $2)", constantExpression=true)
public static boolean operator_greaterEqualsThan(short a, char b) {
return a >= b;
}
/**
* The binary <code>equals</code> operator. This is the equivalent to the Java <code>==</code> operator.
*
* @param a a short.
* @param b a character.
* @return <code>a==b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 == $2)", constantExpression=true)
public static boolean operator_equals(short a, char b) {
return a == b;
}
/**
* The binary <code>notEquals</code> operator. This is the equivalent to the Java <code>!=</code> operator.
*
* @param a a short.
* @param b a character.
* @return <code>a!=b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 != $2)", constantExpression=true)
public static boolean operator_notEquals(short a, char b) {
return a != b;
}
/**
* The binary <code>power</code> operator. This is the equivalent to the Java's <code>Math.pow()</code> function.
*
* @param a a short.
* @param b a character.
* @return <code>Math.pow(a, b)</code>
* @since 2.3
*/
@Pure
@Inline(value="$3.pow($1, $2)", imported=Math.class)
public static double operator_power(short a, char b) {
return Math.pow(a, b);
}
/**
* The <code>identity equals</code> operator. This is the equivalent to Java's <code>==</code>
* operator.
*
* @param a a short.
* @param b a character.
* @return <code>a == b</code>
* @since 2.4
*/
@Pure
@Inline(value="($1 == $2)", constantExpression=true)
public static boolean operator_tripleEquals(short a, char b) {
return a == b;
}
/**
* The <code>identity not equals</code> operator. This is the equivalent to Java's <code>!=</code>
* operator.
*
* @param a a short.
* @param b a character.
* @return <code>a != b</code>
* @since 2.4
*/
@Pure
@Inline(value="($1 != $2)", constantExpression=true)
public static boolean operator_tripleNotEquals(short a, char b) {
return a != b;
}
/**
* The binary <code>plus</code> operator. This is the equivalent to the Java <code>+</code> operator.
*
* @param a a short.
* @param b a short.
* @return <code>a+b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 + $2)", constantExpression=true)
public static int operator_plus(short a, short b) {
return a + b;
}
/**
* The binary <code>minus</code> operator. This is the equivalent to the Java <code>-</code> operator.
*
* @param a a short.
* @param b a short.
* @return <code>a-b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 - $2)", constantExpression=true)
public static int operator_minus(short a, short b) {
return a - b;
}
/**
* The binary <code>multiply</code> operator. This is the equivalent to the Java <code>*</code> operator.
*
* @param a a short.
* @param b a short.
* @return <code>a*b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 * $2)", constantExpression=true)
public static int operator_multiply(short a, short b) {
return a * b;
}
/**
* The binary <code>divide</code> operator. This is the equivalent to the Java <code>/</code> operator.
*
* @param a a short.
* @param b a short.
* @return <code>a/b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 / $2)", constantExpression=true)
public static int operator_divide(short a, short b) {
return a / b;
}
/**
* The binary <code>modulo</code> operator. This is the equivalent to the Java <code>%</code> operator.
*
* @param a a short.
* @param b a short.
* @return <code>a%b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 % $2)", constantExpression=true)
public static int operator_modulo(short a, short b) {
return a % b;
}
/**
* The binary <code>lessThan</code> operator. This is the equivalent to the Java <code>&lt;</code> operator.
*
* @param a a short.
* @param b a short.
* @return <code>a&lt;b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 < $2)", constantExpression=true)
public static boolean operator_lessThan(short a, short b) {
return a < b;
}
/**
* The binary <code>lessEqualsThan</code> operator. This is the equivalent to the Java <code>&lt;=</code> operator.
*
* @param a a short.
* @param b a short.
* @return <code>a&lt;=b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 <= $2)", constantExpression=true)
public static boolean operator_lessEqualsThan(short a, short b) {
return a <= b;
}
/**
* The binary <code>greaterThan</code> operator. This is the equivalent to the Java <code>&gt;</code> operator.
*
* @param a a short.
* @param b a short.
* @return <code>a&gt;b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 > $2)", constantExpression=true)
public static boolean operator_greaterThan(short a, short b) {
return a > b;
}
/**
* The binary <code>greaterEqualsThan</code> operator. This is the equivalent to the Java <code>&gt;=</code> operator.
*
* @param a a short.
* @param b a short.
* @return <code>a&gt;=b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 >= $2)", constantExpression=true)
public static boolean operator_greaterEqualsThan(short a, short b) {
return a >= b;
}
/**
* The binary <code>equals</code> operator. This is the equivalent to the Java <code>==</code> operator.
*
* @param a a short.
* @param b a short.
* @return <code>a==b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 == $2)", constantExpression=true)
public static boolean operator_equals(short a, short b) {
return a == b;
}
/**
* The binary <code>notEquals</code> operator. This is the equivalent to the Java <code>!=</code> operator.
*
* @param a a short.
* @param b a short.
* @return <code>a!=b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 != $2)", constantExpression=true)
public static boolean operator_notEquals(short a, short b) {
return a != b;
}
/**
* The binary <code>power</code> operator. This is the equivalent to the Java's <code>Math.pow()</code> function.
*
* @param a a short.
* @param b a short.
* @return <code>Math.pow(a, b)</code>
* @since 2.3
*/
@Pure
@Inline(value="$3.pow($1, $2)", imported=Math.class)
public static double operator_power(short a, short b) {
return Math.pow(a, b);
}
/**
* The <code>identity equals</code> operator. This is the equivalent to Java's <code>==</code>
* operator.
*
* @param a a short.
* @param b a short.
* @return <code>a == b</code>
* @since 2.4
*/
@Pure
@Inline(value="($1 == $2)", constantExpression=true)
public static boolean operator_tripleEquals(short a, short b) {
return a == b;
}
/**
* The <code>identity not equals</code> operator. This is the equivalent to Java's <code>!=</code>
* operator.
*
* @param a a short.
* @param b a short.
* @return <code>a != b</code>
* @since 2.4
*/
@Pure
@Inline(value="($1 != $2)", constantExpression=true)
public static boolean operator_tripleNotEquals(short a, short b) {
return a != b;
}
/**
* The binary <code>plus</code> operator. This is the equivalent to the Java <code>+</code> operator.
*
* @param a a short.
* @param b a byte.
* @return <code>a+b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 + $2)", constantExpression=true)
public static int operator_plus(short a, byte b) {
return a + b;
}
/**
* The binary <code>minus</code> operator. This is the equivalent to the Java <code>-</code> operator.
*
* @param a a short.
* @param b a byte.
* @return <code>a-b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 - $2)", constantExpression=true)
public static int operator_minus(short a, byte b) {
return a - b;
}
/**
* The binary <code>multiply</code> operator. This is the equivalent to the Java <code>*</code> operator.
*
* @param a a short.
* @param b a byte.
* @return <code>a*b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 * $2)", constantExpression=true)
public static int operator_multiply(short a, byte b) {
return a * b;
}
/**
* The binary <code>divide</code> operator. This is the equivalent to the Java <code>/</code> operator.
*
* @param a a short.
* @param b a byte.
* @return <code>a/b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 / $2)", constantExpression=true)
public static int operator_divide(short a, byte b) {
return a / b;
}
/**
* The binary <code>modulo</code> operator. This is the equivalent to the Java <code>%</code> operator.
*
* @param a a short.
* @param b a byte.
* @return <code>a%b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 % $2)", constantExpression=true)
public static int operator_modulo(short a, byte b) {
return a % b;
}
/**
* The binary <code>lessThan</code> operator. This is the equivalent to the Java <code>&lt;</code> operator.
*
* @param a a short.
* @param b a byte.
* @return <code>a&lt;b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 < $2)", constantExpression=true)
public static boolean operator_lessThan(short a, byte b) {
return a < b;
}
/**
* The binary <code>lessEqualsThan</code> operator. This is the equivalent to the Java <code>&lt;=</code> operator.
*
* @param a a short.
* @param b a byte.
* @return <code>a&lt;=b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 <= $2)", constantExpression=true)
public static boolean operator_lessEqualsThan(short a, byte b) {
return a <= b;
}
/**
* The binary <code>greaterThan</code> operator. This is the equivalent to the Java <code>&gt;</code> operator.
*
* @param a a short.
* @param b a byte.
* @return <code>a&gt;b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 > $2)", constantExpression=true)
public static boolean operator_greaterThan(short a, byte b) {
return a > b;
}
/**
* The binary <code>greaterEqualsThan</code> operator. This is the equivalent to the Java <code>&gt;=</code> operator.
*
* @param a a short.
* @param b a byte.
* @return <code>a&gt;=b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 >= $2)", constantExpression=true)
public static boolean operator_greaterEqualsThan(short a, byte b) {
return a >= b;
}
/**
* The binary <code>equals</code> operator. This is the equivalent to the Java <code>==</code> operator.
*
* @param a a short.
* @param b a byte.
* @return <code>a==b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 == $2)", constantExpression=true)
public static boolean operator_equals(short a, byte b) {
return a == b;
}
/**
* The binary <code>notEquals</code> operator. This is the equivalent to the Java <code>!=</code> operator.
*
* @param a a short.
* @param b a byte.
* @return <code>a!=b</code>
* @since 2.3
*/
@Pure
@Inline(value="($1 != $2)", constantExpression=true)
public static boolean operator_notEquals(short a, byte b) {
return a != b;
}
/**
* The binary <code>power</code> operator. This is the equivalent to the Java's <code>Math.pow()</code> function.
*
* @param a a short.
* @param b a byte.
* @return <code>Math.pow(a, b)</code>
* @since 2.3
*/
@Pure
@Inline(value="$3.pow($1, $2)", imported=Math.class)
public static double operator_power(short a, byte b) {
return Math.pow(a, b);
}
/**
* The <code>identity equals</code> operator. This is the equivalent to Java's <code>==</code>
* operator.
*
* @param a a short.
* @param b a byte.
* @return <code>a == b</code>
* @since 2.4
*/
@Pure
@Inline(value="($1 == $2)", constantExpression=true)
public static boolean operator_tripleEquals(short a, byte b) {
return a == b;
}
/**
* The <code>identity not equals</code> operator. This is the equivalent to Java's <code>!=</code>
* operator.
*
* @param a a short.
* @param b a byte.
* @return <code>a != b</code>
* @since 2.4
*/
@Pure
@Inline(value="($1 != $2)", constantExpression=true)
public static boolean operator_tripleNotEquals(short a, byte b) {
return a != b;
}
// END generated code
}