Examples with GwtIncompatible com.google_voltpatches.common.annotations.GwtIncompatible used on opensource projects

Example 6 with GwtIncompatible

use of com.google_voltpatches.common.annotations.GwtIncompatible in project voltdb by VoltDB.

the class BigIntegerMath method divide.

/**
   * Returns the result of dividing {@code p} by {@code q}, rounding using the specified
   * {@code RoundingMode}.
   *
   * @throws ArithmeticException if {@code q == 0}, or if {@code mode == UNNECESSARY} and {@code a}
   *     is not an integer multiple of {@code b}
   */
// TODO
@GwtIncompatible
public static BigInteger divide(BigInteger p, BigInteger q, RoundingMode mode) {
    BigDecimal pDec = new BigDecimal(p);
    BigDecimal qDec = new BigDecimal(q);
    return pDec.divide(qDec, 0, mode).toBigIntegerExact();
}

Example 7 with GwtIncompatible

use of com.google_voltpatches.common.annotations.GwtIncompatible in project voltdb by VoltDB.

the class Throwables method getJLA.

/**
   * Returns the JavaLangAccess class that is present in all Sun JDKs. It is not whitelisted for
   * AppEngine, and not present in non-Sun JDKs.
   */
// java.lang.reflect
@GwtIncompatible
@Nullable
private static Object getJLA() {
    try {
        /*
       * We load sun.misc.* classes using reflection since Android doesn't support these classes and
       * would result in compilation failure if we directly refer to these classes.
       */
        Class<?> sharedSecrets = Class.forName(SHARED_SECRETS_CLASSNAME, false, null);
        Method langAccess = sharedSecrets.getMethod("getJavaLangAccess");
        return langAccess.invoke(null);
    } catch (ThreadDeath death) {
        throw death;
    } catch (Throwable t) {
        /*
       * This is not one of AppEngine's whitelisted classes, so even in Sun JDKs, this can fail with
       * a NoClassDefFoundError. Other apps might deny access to sun.misc packages.
       */
        return null;
    }
}

Example 8 with GwtIncompatible

use of com.google_voltpatches.common.annotations.GwtIncompatible in project voltdb by VoltDB.

the class MoreExecutors method invokeAnyImpl.

/*
   * This following method is a modified version of one found in
   * http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/src/test/tck/AbstractExecutorServiceTest.java?revision=1.30
   * which contained the following notice:
   *
   * Written by Doug Lea with assistance from members of JCP JSR-166 Expert Group and released to
   * the public domain, as explained at http://creativecommons.org/publicdomain/zero/1.0/
   *
   * Other contributors include Andrew Wright, Jeffrey Hayes, Pat Fisher, Mike Judd.
   */
/**
   * An implementation of {@link ExecutorService#invokeAny} for {@link ListeningExecutorService}
   * implementations.
   */
@GwtIncompatible
static <T> T invokeAnyImpl(ListeningExecutorService executorService, Collection<? extends Callable<T>> tasks, boolean timed, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
    checkNotNull(executorService);
    checkNotNull(unit);
    int ntasks = tasks.size();
    checkArgument(ntasks > 0);
    List<Future<T>> futures = Lists.newArrayListWithCapacity(ntasks);
    BlockingQueue<Future<T>> futureQueue = Queues.newLinkedBlockingQueue();
    long timeoutNanos = unit.toNanos(timeout);
    try {
        // Record exceptions so that if we fail to obtain any
        // result, we can throw the last exception we got.
        ExecutionException ee = null;
        long lastTime = timed ? System.nanoTime() : 0;
        Iterator<? extends Callable<T>> it = tasks.iterator();
        futures.add(submitAndAddQueueListener(executorService, it.next(), futureQueue));
        --ntasks;
        int active = 1;
        while (true) {
            Future<T> f = futureQueue.poll();
            if (f == null) {
                if (ntasks > 0) {
                    --ntasks;
                    futures.add(submitAndAddQueueListener(executorService, it.next(), futureQueue));
                    ++active;
                } else if (active == 0) {
                    break;
                } else if (timed) {
                    f = futureQueue.poll(timeoutNanos, TimeUnit.NANOSECONDS);
                    if (f == null) {
                        throw new TimeoutException();
                    }
                    long now = System.nanoTime();
                    timeoutNanos -= now - lastTime;
                    lastTime = now;
                } else {
                    f = futureQueue.take();
                }
            }
            if (f != null) {
                --active;
                try {
                    return f.get();
                } catch (ExecutionException eex) {
                    ee = eex;
                } catch (RuntimeException rex) {
                    ee = new ExecutionException(rex);
                }
            }
        }
        if (ee == null) {
            ee = new ExecutionException(null);
        }
        throw ee;
    } finally {
        for (Future<T> f : futures) {
            f.cancel(true);
        }
    }
}

Example 9 with GwtIncompatible

use of com.google_voltpatches.common.annotations.GwtIncompatible in project voltdb by VoltDB.

the class Futures method lazyTransform.

/**
   * Like {@link #transform(ListenableFuture, Function)} except that the transformation {@code
   * function} is invoked on each call to {@link Future#get() get()} on the returned future.
   *
   * <p>The returned {@code Future} reflects the input's cancellation state directly, and any
   * attempt to cancel the returned Future is likewise passed through to the input Future.
   *
   * <p>Note that calls to {@linkplain Future#get(long, TimeUnit) timed get} only apply the timeout
   * to the execution of the underlying {@code Future}, <em>not</em> to the execution of the
   * transformation function.
   *
   * <p>The primary audience of this method is callers of {@code transform} who don't have a {@code
   * ListenableFuture} available and do not mind repeated, lazy function evaluation.
   *
   * @param input The future to transform
   * @param function A Function to transform the results of the provided future to the results of
   *     the returned future.
   * @return A future that returns the result of the transformation.
   * @since 10.0
   */
// TODO
@GwtIncompatible
public static <I, O> Future<O> lazyTransform(final Future<I> input, final Function<? super I, ? extends O> function) {
    checkNotNull(input);
    checkNotNull(function);
    return new Future<O>() {

        @Override
        public boolean cancel(boolean mayInterruptIfRunning) {
            return input.cancel(mayInterruptIfRunning);
        }

        @Override
        public boolean isCancelled() {
            return input.isCancelled();
        }

        @Override
        public boolean isDone() {
            return input.isDone();
        }

        @Override
        public O get() throws InterruptedException, ExecutionException {
            return applyTransformation(input.get());
        }

        @Override
        public O get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
            return applyTransformation(input.get(timeout, unit));
        }

        private O applyTransformation(I input) throws ExecutionException {
            try {
                return function.apply(input);
            } catch (Throwable t) {
                throw new ExecutionException(t);
            }
        }
    };
}

Example 10 with GwtIncompatible

use of com.google_voltpatches.common.annotations.GwtIncompatible in project voltdb by VoltDB.

the class DoubleMath method mean.

/**
   * Returns the <a href="http://en.wikipedia.org/wiki/Arithmetic_mean">arithmetic mean</a> of
   * {@code values}.
   *
   * <p>If these values are a sample drawn from a population, this is also an unbiased estimator of
   * the arithmetic mean of the population.
   *
   * @param values a nonempty series of values
   * @throws IllegalArgumentException if {@code values} is empty or contains any non-finite value
   * @deprecated Use {@link Stats#meanOf} instead, noting the less strict handling of non-finite
   *     values. This method will be removed in February 2018.
   */
@Deprecated
// com.google_voltpatches.common.math.DoubleUtils
@GwtIncompatible
public static double mean(double... values) {
    checkArgument(values.length > 0, "Cannot take mean of 0 values");
    long count = 1;
    double mean = checkFinite(values[0]);
    for (int index = 1; index < values.length; ++index) {
        checkFinite(values[index]);
        count++;
        // Art of Computer Programming vol. 2, Knuth, 4.2.2, (15)
        mean += (values[index] - mean) / count;
    }
    return mean;
}