All Downloads are FREE. Search and download functionalities are using the official Maven repository.

net.cassite.f.Op Maven / Gradle / Ivy

package net.cassite.f;

import io.vertx.core.Future;

public class Op {
    private Op() {
    }

    @SuppressWarnings("unchecked")
    private static  T addNumber(T num, T incr) {
        T res;
        if (num instanceof Integer) {
            res = (T) Integer.valueOf(num.intValue() + incr.intValue());
        } else if (num instanceof Float) {
            res = (T) Float.valueOf(num.floatValue() + incr.floatValue());
        } else if (num instanceof Long) {
            res = (T) Long.valueOf(num.longValue() + incr.longValue());
        } else if (num instanceof Double) {
            res = (T) Double.valueOf(num.doubleValue() + incr.doubleValue());
        } else if (num instanceof Short) {
            res = (T) Short.valueOf((short) (num.shortValue() + incr.shortValue()));
        } else if (num instanceof Byte) {
            res = (T) Byte.valueOf((byte) (num.byteValue() + incr.byteValue()));
        } else {
            throw new IllegalArgumentException("only int/float/double/long/short/byte allowed");
        }
        return res;
    }

    @SuppressWarnings("unchecked")
    private static  T subNumber(T num, T incr) {
        T res;
        if (num instanceof Integer) {
            res = (T) Integer.valueOf(num.intValue() - incr.intValue());
        } else if (num instanceof Float) {
            res = (T) Float.valueOf(num.floatValue() - incr.floatValue());
        } else if (num instanceof Long) {
            res = (T) Long.valueOf(num.longValue() - incr.longValue());
        } else if (num instanceof Double) {
            res = (T) Double.valueOf(num.doubleValue() - incr.doubleValue());
        } else if (num instanceof Short) {
            res = (T) Short.valueOf((short) (num.shortValue() - incr.shortValue()));
        } else if (num instanceof Byte) {
            res = (T) Byte.valueOf((byte) (num.byteValue() - incr.byteValue()));
        } else {
            throw new IllegalArgumentException("only int/float/double/long/short/byte allowed");
        }
        return res;
    }

    @SuppressWarnings("unchecked")
    private static  T multiNumber(T num, T incr) {
        T res;
        if (num instanceof Integer) {
            res = (T) Integer.valueOf(num.intValue() * incr.intValue());
        } else if (num instanceof Float) {
            res = (T) Float.valueOf(num.floatValue() * incr.floatValue());
        } else if (num instanceof Long) {
            res = (T) Long.valueOf(num.longValue() * incr.longValue());
        } else if (num instanceof Double) {
            res = (T) Double.valueOf(num.doubleValue() * incr.doubleValue());
        } else if (num instanceof Short) {
            res = (T) Short.valueOf((short) (num.shortValue() * incr.shortValue()));
        } else if (num instanceof Byte) {
            res = (T) Byte.valueOf((byte) (num.byteValue() * incr.byteValue()));
        } else {
            throw new IllegalArgumentException("only int/float/double/long/short/byte allowed");
        }
        return res;
    }

    @SuppressWarnings("unchecked")
    private static  T divNumber(T num, T incr) {
        T res;
        if (num instanceof Integer) {
            res = (T) Integer.valueOf(num.intValue() / incr.intValue());
        } else if (num instanceof Float) {
            res = (T) Float.valueOf(num.floatValue() / incr.floatValue());
        } else if (num instanceof Long) {
            res = (T) Long.valueOf(num.longValue() / incr.longValue());
        } else if (num instanceof Double) {
            res = (T) Double.valueOf(num.doubleValue() / incr.doubleValue());
        } else if (num instanceof Short) {
            res = (T) Short.valueOf((short) (num.shortValue() / incr.shortValue()));
        } else if (num instanceof Byte) {
            res = (T) Byte.valueOf((byte) (num.byteValue() / incr.byteValue()));
        } else {
            throw new IllegalArgumentException("only int/float/double/long/short/byte allowed");
        }
        return res;
    }

    @SuppressWarnings("unchecked")
    private static  T modNumber(T num, T incr) {
        T res;
        if (num instanceof Integer) {
            res = (T) Integer.valueOf(num.intValue() % incr.intValue());
        } else if (num instanceof Float) {
            res = (T) Float.valueOf(num.floatValue() % incr.floatValue());
        } else if (num instanceof Long) {
            res = (T) Long.valueOf(num.longValue() % incr.longValue());
        } else if (num instanceof Double) {
            res = (T) Double.valueOf(num.doubleValue() % incr.doubleValue());
        } else if (num instanceof Short) {
            res = (T) Short.valueOf((short) (num.shortValue() % incr.shortValue()));
        } else if (num instanceof Byte) {
            res = (T) Byte.valueOf((byte) (num.byteValue() % incr.byteValue()));
        } else {
            throw new IllegalArgumentException("only int/float/double/long/short/byte allowed");
        }
        return res;
    }

    @SuppressWarnings("unchecked")
    private static  T bitAndNumber(T a, T b) {
        T res;
        if (a instanceof Integer) {
            res = (T) Integer.valueOf(a.intValue() & b.intValue());
        } else if (a instanceof Long) {
            res = (T) Long.valueOf(a.longValue() & b.longValue());
        } else if (a instanceof Short) {
            res = (T) Short.valueOf((short) (a.shortValue() & b.shortValue()));
        } else if (a instanceof Byte) {
            res = (T) Byte.valueOf((byte) (a.byteValue() & b.byteValue()));
        } else {
            throw new IllegalArgumentException("only int/long/short/byte allowed");
        }
        return res;
    }

    @SuppressWarnings("unchecked")
    private static  T bitOrNumber(T a, T b) {
        T res;
        if (a instanceof Integer) {
            res = (T) Integer.valueOf(a.intValue() | b.intValue());
        } else if (a instanceof Long) {
            res = (T) Long.valueOf(a.longValue() | b.longValue());
        } else if (a instanceof Short) {
            res = (T) Short.valueOf((short) (a.shortValue() | b.shortValue()));
        } else if (a instanceof Byte) {
            res = (T) Byte.valueOf((byte) (a.byteValue() | b.byteValue()));
        } else {
            throw new IllegalArgumentException("only int/long/short/byte allowed");
        }
        return res;
    }

    // !
    public static Monad not(Ptr ptr) {
        boolean b = ptr.value;
        return Monad.unit(!b);
    }

    // ++i
    @SuppressWarnings("unchecked")
    public static  Monad leftIncr(Ptr ptr) {
        T num = ptr.value;
        Number n = addNumber(num, 1);
        ptr.value = (T) n;
        return Monad.unit((T) n);
    }

    // i++
    @SuppressWarnings("unchecked")
    public static  Monad rightIncr(Ptr ptr) {
        T num = ptr.value;
        Number n = addNumber(num, 1);
        ptr.value = (T) n;
        return Monad.unit(num);
    }

    // --i
    @SuppressWarnings("unchecked")
    public static  Monad leftDecr(Ptr ptr) {
        T num = ptr.value;
        Number n = subNumber(num, 1);
        ptr.value = (T) n;
        return Monad.unit((T) n);
    }

    // i--
    @SuppressWarnings("unchecked")
    public static  Monad rightDecr(Ptr ptr) {
        T num = ptr.value;
        Number n = subNumber(num, 1);
        ptr.value = (T) n;
        return Monad.unit(num);
    }

    // &&
    public static Monad and(Ptr ptr, Future v) {
        return Monad.transform(v.map(vv -> ptr.value && vv));
    }

    // ||
    public static Monad or(Ptr ptr, Future v) {
        return Monad.transform(v.map(vv -> ptr.value || vv));
    }

    // &=
    public static  Monad bitAndAsn(Ptr ptr, Future v) {
        return Monad.transform(v.map(vv -> {
            T num = ptr.value;
            T n = (T) bitAndNumber(num, vv);
            ptr.value = n;
            return n;
        }));
    }

    // |=
    public static  Monad bitOrAsn(Ptr ptr, Future v) {
        return Monad.transform(v.map(vv -> {
            T num = ptr.value;
            T n = bitOrNumber(num, vv);
            ptr.value = n;
            return n;
        }));
    }

    // +=
    public static  Monad incr(Ptr ptr, Future v) {
        return Monad.transform(v.map(vv -> {
            T num = ptr.value;
            T n = addNumber(num, vv);
            ptr.value = n;
            return n;
        }));
    }

    // -=
    public static  Monad decr(Ptr ptr, Future v) {
        return Monad.transform(v.map(vv -> {
            T num = ptr.value;
            T n = subNumber(num, vv);
            ptr.value = n;
            return n;
        }));
    }

    // *=
    public static  Monad mulAsn(Ptr ptr, Future v) {
        return Monad.transform(v.map(vv -> {
            T num = ptr.value;
            T n = multiNumber(num, vv);
            ptr.value = n;
            return n;
        }));
    }

    // /=
    public static  Monad divAsn(Ptr ptr, Future v) {
        return Monad.transform(v.map(vv -> {
            T num = ptr.value;
            T n = divNumber(num, vv);
            ptr.value = n;
            return n;
        }));
    }

    // %=
    public static  Monad modAsn(Ptr ptr, Future v) {
        return Monad.transform(v.map(vv -> {
            T num = ptr.value;
            T n = modNumber(num, vv);
            ptr.value = n;
            return n;
        }));
    }

    // +
    public static  Monad plus(Ptr ptr, Future v) {
        return Monad.transform(v.map(vv -> {
            T num = ptr.value;
            return addNumber(num, vv);
        }));
    }

    // -
    public static  Monad minus(Ptr ptr, Future v) {
        return Monad.transform(v.map(vv -> {
            T num = ptr.value;
            return subNumber(num, vv);
        }));
    }

    // *
    public static  Monad multiply(Ptr ptr, Future v) {
        return Monad.transform(v.map(vv -> {
            T num = ptr.value;
            return multiNumber(num, vv);
        }));
    }

    // /
    public static  Monad divide(Ptr ptr, Future v) {
        return Monad.transform(v.map(vv -> {
            T num = ptr.value;
            return divNumber(num, vv);
        }));
    }

    // %
    public static  Monad mod(Ptr ptr, Future v) {
        return Monad.transform(v.map(vv -> {
            T num = ptr.value;
            return modNumber(num, vv);
        }));
    }

    // &
    public static  Monad bitAnd(Ptr ptr, Future v) {
        return Monad.transform(v.map(vv -> {
            T num = ptr.value;
            return bitAndNumber(num, vv);
        }));
    }

    // |
    public static  Monad bitOr(Ptr ptr, Future v) {
        return Monad.transform(v.map(vv -> {
            T num = ptr.value;
            return bitOrNumber(num, vv);
        }));
    }
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy