ByteMath.java

package org.checkerframework.common.value.util;

public class ByteMath extends NumberMath<Byte> {
    byte number;

    public ByteMath(byte i) {
        number = i;
    }

    @Override
    public Number plus(Number right) {
        if (right instanceof Byte) {
            return number + right.byteValue();
        }
        if (right instanceof Double) {
            return number + right.doubleValue();
        }
        if (right instanceof Float) {
            return number + right.floatValue();
        }
        if (right instanceof Integer) {
            return number + right.intValue();
        }
        if (right instanceof Long) {
            return number + right.longValue();
        }
        if (right instanceof Short) {
            return number + right.shortValue();
        }
        throw new UnsupportedOperationException();
    }

    @Override
    public Number minus(Number right) {
        if (right instanceof Byte) {
            return number - right.byteValue();
        }
        if (right instanceof Double) {
            return number - right.doubleValue();
        }
        if (right instanceof Float) {
            return number - right.floatValue();
        }
        if (right instanceof Integer) {
            return number - right.intValue();
        }
        if (right instanceof Long) {
            return number - right.longValue();
        }
        if (right instanceof Short) {
            return number - right.shortValue();
        }
        throw new UnsupportedOperationException();
    }

    @Override
    public Number times(Number right) {
        if (right instanceof Byte) {
            return number * right.byteValue();
        }
        if (right instanceof Double) {
            return number * right.doubleValue();
        }
        if (right instanceof Float) {
            return number * right.floatValue();
        }
        if (right instanceof Integer) {
            return number * right.intValue();
        }
        if (right instanceof Long) {
            return number * right.longValue();
        }
        if (right instanceof Short) {
            return number * right.shortValue();
        }
        throw new UnsupportedOperationException();
    }

    @Override
    public Number divide(Number right) {
        if (isIntegralZero(right)) {
            return null;
        }
        if (right instanceof Byte) {
            return number / right.byteValue();
        }
        if (right instanceof Double) {
            return number / right.doubleValue();
        }
        if (right instanceof Float) {
            return number / right.floatValue();
        }
        if (right instanceof Integer) {
            return number / right.intValue();
        }
        if (right instanceof Long) {
            return number / right.longValue();
        }
        if (right instanceof Short) {
            return number / right.shortValue();
        }
        throw new UnsupportedOperationException();
    }

    @Override
    public Number remainder(Number right) {
        if (isIntegralZero(right)) {
            return null;
        }
        if (right instanceof Byte) {
            return number % right.byteValue();
        }
        if (right instanceof Double) {
            return number % right.doubleValue();
        }
        if (right instanceof Float) {
            return number % right.floatValue();
        }
        if (right instanceof Integer) {
            return number % right.intValue();
        }
        if (right instanceof Long) {
            return number % right.longValue();
        }
        if (right instanceof Short) {
            return number % right.shortValue();
        }
        throw new UnsupportedOperationException();
    }

    @Override
    public Number shiftLeft(Number right) {
        if (right instanceof Byte) {
            return number << right.byteValue();
        }
        if (right instanceof Integer) {
            return number << right.intValue();
        }
        if (right instanceof Long) {
            return number << right.longValue();
        }
        if (right instanceof Short) {
            return number << right.shortValue();
        }
        throw new UnsupportedOperationException();
    }

    @Override
    public Number signedShiftRight(Number right) {
        if (right instanceof Byte) {
            return number >> right.byteValue();
        }
        if (right instanceof Integer) {
            return number >> right.intValue();
        }
        if (right instanceof Long) {
            return number >> right.longValue();
        }
        if (right instanceof Short) {
            return number >> right.shortValue();
        }
        throw new UnsupportedOperationException();
    }

    @Override
    public Number unsignedShiftRight(Number right) {
        if (right instanceof Byte) {
            return number >>> right.byteValue();
        }
        if (right instanceof Integer) {
            return number >>> right.intValue();
        }
        if (right instanceof Long) {
            return number >>> right.longValue();
        }
        if (right instanceof Short) {
            return number >>> right.shortValue();
        }
        throw new UnsupportedOperationException();
    }

    @Override
    public Number bitwiseAnd(Number right) {
        if (right instanceof Byte) {
            return number & right.byteValue();
        }
        if (right instanceof Integer) {
            return number & right.intValue();
        }
        if (right instanceof Long) {
            return number & right.longValue();
        }
        if (right instanceof Short) {
            return number & right.shortValue();
        }
        throw new UnsupportedOperationException();
    }

    @Override
    public Number bitwiseXor(Number right) {
        if (right instanceof Byte) {
            return number ^ right.byteValue();
        }
        if (right instanceof Integer) {
            return number ^ right.intValue();
        }
        if (right instanceof Long) {
            return number ^ right.longValue();
        }
        if (right instanceof Short) {
            return number ^ right.shortValue();
        }
        throw new UnsupportedOperationException();
    }

    @Override
    public Number bitwiseOr(Number right) {
        if (right instanceof Byte) {
            return number | right.byteValue();
        }
        if (right instanceof Integer) {
            return number | right.intValue();
        }
        if (right instanceof Long) {
            return number | right.longValue();
        }
        if (right instanceof Short) {
            return number | right.shortValue();
        }
        throw new UnsupportedOperationException();
    }

    @Override
    public Number unaryPlus() {
        return +number;
    }

    @Override
    public Number unaryMinus() {
        return -number;
    }

    @Override
    public Number bitwiseComplement() {
        return ~number;
    }

    @Override
    public Boolean equalTo(Number right) {
        if (right instanceof Byte) {
            return number == right.byteValue();
        }
        if (right instanceof Double) {
            return number == right.doubleValue();
        }
        if (right instanceof Float) {
            return number == right.floatValue();
        }
        if (right instanceof Integer) {
            return number == right.intValue();
        }
        if (right instanceof Long) {
            return number == right.longValue();
        }
        if (right instanceof Short) {
            return number == right.shortValue();
        }
        throw new UnsupportedOperationException();
    }

    @Override
    public Boolean notEqualTo(Number right) {
        if (right instanceof Byte) {
            return number != right.byteValue();
        }
        if (right instanceof Double) {
            return number != right.doubleValue();
        }
        if (right instanceof Float) {
            return number != right.floatValue();
        }
        if (right instanceof Integer) {
            return number != right.intValue();
        }
        if (right instanceof Long) {
            return number != right.longValue();
        }
        if (right instanceof Short) {
            return number != right.shortValue();
        }
        throw new UnsupportedOperationException();
    }

    @Override
    public Boolean greaterThan(Number right) {
        if (right instanceof Byte) {
            return number > right.byteValue();
        }
        if (right instanceof Double) {
            return number > right.doubleValue();
        }
        if (right instanceof Float) {
            return number > right.floatValue();
        }
        if (right instanceof Integer) {
            return number > right.intValue();
        }
        if (right instanceof Long) {
            return number > right.longValue();
        }
        if (right instanceof Short) {
            return number > right.shortValue();
        }
        throw new UnsupportedOperationException();
    }

    @Override
    public Boolean greaterThanEq(Number right) {
        if (right instanceof Byte) {
            return number >= right.byteValue();
        }
        if (right instanceof Double) {
            return number >= right.doubleValue();
        }
        if (right instanceof Float) {
            return number >= right.floatValue();
        }
        if (right instanceof Integer) {
            return number >= right.intValue();
        }
        if (right instanceof Long) {
            return number >= right.longValue();
        }
        if (right instanceof Short) {
            return number >= right.shortValue();
        }
        throw new UnsupportedOperationException();
    }

    @Override
    public Boolean lessThan(Number right) {
        if (right instanceof Byte) {
            return number < right.byteValue();
        }
        if (right instanceof Double) {
            return number < right.doubleValue();
        }
        if (right instanceof Float) {
            return number < right.floatValue();
        }
        if (right instanceof Integer) {
            return number < right.intValue();
        }
        if (right instanceof Long) {
            return number < right.longValue();
        }
        if (right instanceof Short) {
            return number < right.shortValue();
        }
        throw new UnsupportedOperationException();
    }

    @Override
    public Boolean lessThanEq(Number right) {
        if (right instanceof Byte) {
            return number <= right.byteValue();
        }
        if (right instanceof Double) {
            return number <= right.doubleValue();
        }
        if (right instanceof Float) {
            return number <= right.floatValue();
        }
        if (right instanceof Integer) {
            return number <= right.intValue();
        }
        if (right instanceof Long) {
            return number <= right.longValue();
        }
        if (right instanceof Short) {
            return number <= right.shortValue();
        }
        throw new UnsupportedOperationException();
    }
}