ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/main/java/util/SplittableRandom.java
(Generate patch)

Comparing jsr166/src/main/java/util/SplittableRandom.java (file contents):
Revision 1.27 by jsr166, Sun Sep 13 16:28:14 2015 UTC vs.
Revision 1.30 by jsr166, Sat Jan 2 02:27:03 2016 UTC

# Line 225 | Line 225 | public final class SplittableRandom {
225      private static final AtomicLong defaultGen = new AtomicLong(initialSeed());
226  
227      private static long initialSeed() {
228 <        String pp = java.security.AccessController.doPrivileged(
229 <                new sun.security.action.GetPropertyAction(
230 <                        "java.util.secureRandomSeed"));
231 <        if (pp != null && pp.equalsIgnoreCase("true")) {
228 >        java.security.PrivilegedAction<Boolean> action =
229 >            () -> Boolean.getBoolean("java.util.secureRandomSeed");
230 >        if (java.security.AccessController.doPrivileged(action)) {
231              byte[] seedBytes = java.security.SecureRandom.getSeed(8);
232 <            long s = (long)(seedBytes[0]) & 0xffL;
232 >            long s = (long)seedBytes[0] & 0xffL;
233              for (int i = 1; i < 8; ++i)
234 <                s = (s << 8) | ((long)(seedBytes[i]) & 0xffL);
234 >                s = (s << 8) | ((long)seedBytes[i] & 0xffL);
235              return s;
236          }
237          return (mix64(System.currentTimeMillis()) ^
# Line 240 | Line 239 | public final class SplittableRandom {
239      }
240  
241      // IllegalArgumentException messages
242 <    static final String BadBound = "bound must be positive";
243 <    static final String BadRange = "bound must be greater than origin";
244 <    static final String BadSize  = "size must be non-negative";
242 >    static final String BAD_BOUND = "bound must be positive";
243 >    static final String BAD_RANGE = "bound must be greater than origin";
244 >    static final String BAD_SIZE  = "size must be non-negative";
245  
246      /*
247       * Internal versions of nextX methods used by streams, as well as
# Line 416 | Line 415 | public final class SplittableRandom {
415       */
416      public int nextInt(int bound) {
417          if (bound <= 0)
418 <            throw new IllegalArgumentException(BadBound);
418 >            throw new IllegalArgumentException(BAD_BOUND);
419          // Specialize internalNextInt for origin 0
420          int r = mix32(nextSeed());
421          int m = bound - 1;
# Line 444 | Line 443 | public final class SplittableRandom {
443       */
444      public int nextInt(int origin, int bound) {
445          if (origin >= bound)
446 <            throw new IllegalArgumentException(BadRange);
446 >            throw new IllegalArgumentException(BAD_RANGE);
447          return internalNextInt(origin, bound);
448      }
449  
# Line 468 | Line 467 | public final class SplittableRandom {
467       */
468      public long nextLong(long bound) {
469          if (bound <= 0)
470 <            throw new IllegalArgumentException(BadBound);
470 >            throw new IllegalArgumentException(BAD_BOUND);
471          // Specialize internalNextLong for origin 0
472          long r = mix64(nextSeed());
473          long m = bound - 1;
# Line 496 | Line 495 | public final class SplittableRandom {
495       */
496      public long nextLong(long origin, long bound) {
497          if (origin >= bound)
498 <            throw new IllegalArgumentException(BadRange);
498 >            throw new IllegalArgumentException(BAD_RANGE);
499          return internalNextLong(origin, bound);
500      }
501  
# Line 522 | Line 521 | public final class SplittableRandom {
521       */
522      public double nextDouble(double bound) {
523          if (!(bound > 0.0))
524 <            throw new IllegalArgumentException(BadBound);
524 >            throw new IllegalArgumentException(BAD_BOUND);
525          double result = (mix64(nextSeed()) >>> 11) * DOUBLE_UNIT * bound;
526          return (result < bound) ?  result : // correct for rounding
527              Double.longBitsToDouble(Double.doubleToLongBits(bound) - 1);
# Line 541 | Line 540 | public final class SplittableRandom {
540       */
541      public double nextDouble(double origin, double bound) {
542          if (!(origin < bound))
543 <            throw new IllegalArgumentException(BadRange);
543 >            throw new IllegalArgumentException(BAD_RANGE);
544          return internalNextDouble(origin, bound);
545      }
546  
# Line 569 | Line 568 | public final class SplittableRandom {
568       */
569      public IntStream ints(long streamSize) {
570          if (streamSize < 0L)
571 <            throw new IllegalArgumentException(BadSize);
571 >            throw new IllegalArgumentException(BAD_SIZE);
572          return StreamSupport.intStream
573              (new RandomIntsSpliterator
574               (this, 0L, streamSize, Integer.MAX_VALUE, 0),
# Line 610 | Line 609 | public final class SplittableRandom {
609      public IntStream ints(long streamSize, int randomNumberOrigin,
610                            int randomNumberBound) {
611          if (streamSize < 0L)
612 <            throw new IllegalArgumentException(BadSize);
612 >            throw new IllegalArgumentException(BAD_SIZE);
613          if (randomNumberOrigin >= randomNumberBound)
614 <            throw new IllegalArgumentException(BadRange);
614 >            throw new IllegalArgumentException(BAD_RANGE);
615          return StreamSupport.intStream
616              (new RandomIntsSpliterator
617               (this, 0L, streamSize, randomNumberOrigin, randomNumberBound),
# Line 636 | Line 635 | public final class SplittableRandom {
635       */
636      public IntStream ints(int randomNumberOrigin, int randomNumberBound) {
637          if (randomNumberOrigin >= randomNumberBound)
638 <            throw new IllegalArgumentException(BadRange);
638 >            throw new IllegalArgumentException(BAD_RANGE);
639          return StreamSupport.intStream
640              (new RandomIntsSpliterator
641               (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
# Line 655 | Line 654 | public final class SplittableRandom {
654       */
655      public LongStream longs(long streamSize) {
656          if (streamSize < 0L)
657 <            throw new IllegalArgumentException(BadSize);
657 >            throw new IllegalArgumentException(BAD_SIZE);
658          return StreamSupport.longStream
659              (new RandomLongsSpliterator
660               (this, 0L, streamSize, Long.MAX_VALUE, 0L),
# Line 696 | Line 695 | public final class SplittableRandom {
695      public LongStream longs(long streamSize, long randomNumberOrigin,
696                              long randomNumberBound) {
697          if (streamSize < 0L)
698 <            throw new IllegalArgumentException(BadSize);
698 >            throw new IllegalArgumentException(BAD_SIZE);
699          if (randomNumberOrigin >= randomNumberBound)
700 <            throw new IllegalArgumentException(BadRange);
700 >            throw new IllegalArgumentException(BAD_RANGE);
701          return StreamSupport.longStream
702              (new RandomLongsSpliterator
703               (this, 0L, streamSize, randomNumberOrigin, randomNumberBound),
# Line 722 | Line 721 | public final class SplittableRandom {
721       */
722      public LongStream longs(long randomNumberOrigin, long randomNumberBound) {
723          if (randomNumberOrigin >= randomNumberBound)
724 <            throw new IllegalArgumentException(BadRange);
724 >            throw new IllegalArgumentException(BAD_RANGE);
725          return StreamSupport.longStream
726              (new RandomLongsSpliterator
727               (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
# Line 741 | Line 740 | public final class SplittableRandom {
740       */
741      public DoubleStream doubles(long streamSize) {
742          if (streamSize < 0L)
743 <            throw new IllegalArgumentException(BadSize);
743 >            throw new IllegalArgumentException(BAD_SIZE);
744          return StreamSupport.doubleStream
745              (new RandomDoublesSpliterator
746               (this, 0L, streamSize, Double.MAX_VALUE, 0.0),
# Line 784 | Line 783 | public final class SplittableRandom {
783      public DoubleStream doubles(long streamSize, double randomNumberOrigin,
784                                  double randomNumberBound) {
785          if (streamSize < 0L)
786 <            throw new IllegalArgumentException(BadSize);
786 >            throw new IllegalArgumentException(BAD_SIZE);
787          if (!(randomNumberOrigin < randomNumberBound))
788 <            throw new IllegalArgumentException(BadRange);
788 >            throw new IllegalArgumentException(BAD_RANGE);
789          return StreamSupport.doubleStream
790              (new RandomDoublesSpliterator
791               (this, 0L, streamSize, randomNumberOrigin, randomNumberBound),
# Line 810 | Line 809 | public final class SplittableRandom {
809       */
810      public DoubleStream doubles(double randomNumberOrigin, double randomNumberBound) {
811          if (!(randomNumberOrigin < randomNumberBound))
812 <            throw new IllegalArgumentException(BadRange);
812 >            throw new IllegalArgumentException(BAD_RANGE);
813          return StreamSupport.doubleStream
814              (new RandomDoublesSpliterator
815               (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
# Line 825 | Line 824 | public final class SplittableRandom {
824       * approach. The long and double versions of this class are
825       * identical except for types.
826       */
827 <    static final class RandomIntsSpliterator implements Spliterator.OfInt {
827 >    private static final class RandomIntsSpliterator
828 >            implements Spliterator.OfInt {
829          final SplittableRandom rng;
830          long index;
831          final long fence;
# Line 880 | Line 880 | public final class SplittableRandom {
880      /**
881       * Spliterator for long streams.
882       */
883 <    static final class RandomLongsSpliterator implements Spliterator.OfLong {
883 >    private static final class RandomLongsSpliterator
884 >            implements Spliterator.OfLong {
885          final SplittableRandom rng;
886          long index;
887          final long fence;
# Line 936 | Line 937 | public final class SplittableRandom {
937      /**
938       * Spliterator for double streams.
939       */
940 <    static final class RandomDoublesSpliterator implements Spliterator.OfDouble {
940 >    private static final class RandomDoublesSpliterator
941 >            implements Spliterator.OfDouble {
942          final SplittableRandom rng;
943          long index;
944          final long fence;

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines