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.31 by jsr166, Fri Feb 19 03:39:15 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 >        if (java.security.AccessController.doPrivileged(
229 >            new java.security.PrivilegedAction<Boolean>() {
230 >                public Boolean run() {
231 >                    return Boolean.getBoolean("java.util.secureRandomSeed");
232 >                }})) {
233              byte[] seedBytes = java.security.SecureRandom.getSeed(8);
234 <            long s = (long)(seedBytes[0]) & 0xffL;
234 >            long s = (long)seedBytes[0] & 0xffL;
235              for (int i = 1; i < 8; ++i)
236 <                s = (s << 8) | ((long)(seedBytes[i]) & 0xffL);
236 >                s = (s << 8) | ((long)seedBytes[i] & 0xffL);
237              return s;
238          }
239          return (mix64(System.currentTimeMillis()) ^
# Line 240 | Line 241 | public final class SplittableRandom {
241      }
242  
243      // IllegalArgumentException messages
244 <    static final String BadBound = "bound must be positive";
245 <    static final String BadRange = "bound must be greater than origin";
246 <    static final String BadSize  = "size must be non-negative";
244 >    static final String BAD_BOUND = "bound must be positive";
245 >    static final String BAD_RANGE = "bound must be greater than origin";
246 >    static final String BAD_SIZE  = "size must be non-negative";
247  
248      /*
249       * Internal versions of nextX methods used by streams, as well as
# Line 416 | Line 417 | public final class SplittableRandom {
417       */
418      public int nextInt(int bound) {
419          if (bound <= 0)
420 <            throw new IllegalArgumentException(BadBound);
420 >            throw new IllegalArgumentException(BAD_BOUND);
421          // Specialize internalNextInt for origin 0
422          int r = mix32(nextSeed());
423          int m = bound - 1;
# Line 444 | Line 445 | public final class SplittableRandom {
445       */
446      public int nextInt(int origin, int bound) {
447          if (origin >= bound)
448 <            throw new IllegalArgumentException(BadRange);
448 >            throw new IllegalArgumentException(BAD_RANGE);
449          return internalNextInt(origin, bound);
450      }
451  
# Line 468 | Line 469 | public final class SplittableRandom {
469       */
470      public long nextLong(long bound) {
471          if (bound <= 0)
472 <            throw new IllegalArgumentException(BadBound);
472 >            throw new IllegalArgumentException(BAD_BOUND);
473          // Specialize internalNextLong for origin 0
474          long r = mix64(nextSeed());
475          long m = bound - 1;
# Line 496 | Line 497 | public final class SplittableRandom {
497       */
498      public long nextLong(long origin, long bound) {
499          if (origin >= bound)
500 <            throw new IllegalArgumentException(BadRange);
500 >            throw new IllegalArgumentException(BAD_RANGE);
501          return internalNextLong(origin, bound);
502      }
503  
# Line 522 | Line 523 | public final class SplittableRandom {
523       */
524      public double nextDouble(double bound) {
525          if (!(bound > 0.0))
526 <            throw new IllegalArgumentException(BadBound);
526 >            throw new IllegalArgumentException(BAD_BOUND);
527          double result = (mix64(nextSeed()) >>> 11) * DOUBLE_UNIT * bound;
528          return (result < bound) ?  result : // correct for rounding
529              Double.longBitsToDouble(Double.doubleToLongBits(bound) - 1);
# Line 541 | Line 542 | public final class SplittableRandom {
542       */
543      public double nextDouble(double origin, double bound) {
544          if (!(origin < bound))
545 <            throw new IllegalArgumentException(BadRange);
545 >            throw new IllegalArgumentException(BAD_RANGE);
546          return internalNextDouble(origin, bound);
547      }
548  
# Line 569 | Line 570 | public final class SplittableRandom {
570       */
571      public IntStream ints(long streamSize) {
572          if (streamSize < 0L)
573 <            throw new IllegalArgumentException(BadSize);
573 >            throw new IllegalArgumentException(BAD_SIZE);
574          return StreamSupport.intStream
575              (new RandomIntsSpliterator
576               (this, 0L, streamSize, Integer.MAX_VALUE, 0),
# Line 610 | Line 611 | public final class SplittableRandom {
611      public IntStream ints(long streamSize, int randomNumberOrigin,
612                            int randomNumberBound) {
613          if (streamSize < 0L)
614 <            throw new IllegalArgumentException(BadSize);
614 >            throw new IllegalArgumentException(BAD_SIZE);
615          if (randomNumberOrigin >= randomNumberBound)
616 <            throw new IllegalArgumentException(BadRange);
616 >            throw new IllegalArgumentException(BAD_RANGE);
617          return StreamSupport.intStream
618              (new RandomIntsSpliterator
619               (this, 0L, streamSize, randomNumberOrigin, randomNumberBound),
# Line 636 | Line 637 | public final class SplittableRandom {
637       */
638      public IntStream ints(int randomNumberOrigin, int randomNumberBound) {
639          if (randomNumberOrigin >= randomNumberBound)
640 <            throw new IllegalArgumentException(BadRange);
640 >            throw new IllegalArgumentException(BAD_RANGE);
641          return StreamSupport.intStream
642              (new RandomIntsSpliterator
643               (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
# Line 655 | Line 656 | public final class SplittableRandom {
656       */
657      public LongStream longs(long streamSize) {
658          if (streamSize < 0L)
659 <            throw new IllegalArgumentException(BadSize);
659 >            throw new IllegalArgumentException(BAD_SIZE);
660          return StreamSupport.longStream
661              (new RandomLongsSpliterator
662               (this, 0L, streamSize, Long.MAX_VALUE, 0L),
# Line 696 | Line 697 | public final class SplittableRandom {
697      public LongStream longs(long streamSize, long randomNumberOrigin,
698                              long randomNumberBound) {
699          if (streamSize < 0L)
700 <            throw new IllegalArgumentException(BadSize);
700 >            throw new IllegalArgumentException(BAD_SIZE);
701          if (randomNumberOrigin >= randomNumberBound)
702 <            throw new IllegalArgumentException(BadRange);
702 >            throw new IllegalArgumentException(BAD_RANGE);
703          return StreamSupport.longStream
704              (new RandomLongsSpliterator
705               (this, 0L, streamSize, randomNumberOrigin, randomNumberBound),
# Line 722 | Line 723 | public final class SplittableRandom {
723       */
724      public LongStream longs(long randomNumberOrigin, long randomNumberBound) {
725          if (randomNumberOrigin >= randomNumberBound)
726 <            throw new IllegalArgumentException(BadRange);
726 >            throw new IllegalArgumentException(BAD_RANGE);
727          return StreamSupport.longStream
728              (new RandomLongsSpliterator
729               (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
# Line 741 | Line 742 | public final class SplittableRandom {
742       */
743      public DoubleStream doubles(long streamSize) {
744          if (streamSize < 0L)
745 <            throw new IllegalArgumentException(BadSize);
745 >            throw new IllegalArgumentException(BAD_SIZE);
746          return StreamSupport.doubleStream
747              (new RandomDoublesSpliterator
748               (this, 0L, streamSize, Double.MAX_VALUE, 0.0),
# Line 784 | Line 785 | public final class SplittableRandom {
785      public DoubleStream doubles(long streamSize, double randomNumberOrigin,
786                                  double randomNumberBound) {
787          if (streamSize < 0L)
788 <            throw new IllegalArgumentException(BadSize);
788 >            throw new IllegalArgumentException(BAD_SIZE);
789          if (!(randomNumberOrigin < randomNumberBound))
790 <            throw new IllegalArgumentException(BadRange);
790 >            throw new IllegalArgumentException(BAD_RANGE);
791          return StreamSupport.doubleStream
792              (new RandomDoublesSpliterator
793               (this, 0L, streamSize, randomNumberOrigin, randomNumberBound),
# Line 810 | Line 811 | public final class SplittableRandom {
811       */
812      public DoubleStream doubles(double randomNumberOrigin, double randomNumberBound) {
813          if (!(randomNumberOrigin < randomNumberBound))
814 <            throw new IllegalArgumentException(BadRange);
814 >            throw new IllegalArgumentException(BAD_RANGE);
815          return StreamSupport.doubleStream
816              (new RandomDoublesSpliterator
817               (this, 0L, Long.MAX_VALUE, randomNumberOrigin, randomNumberBound),
# Line 825 | Line 826 | public final class SplittableRandom {
826       * approach. The long and double versions of this class are
827       * identical except for types.
828       */
829 <    static final class RandomIntsSpliterator implements Spliterator.OfInt {
829 >    private static final class RandomIntsSpliterator
830 >            implements Spliterator.OfInt {
831          final SplittableRandom rng;
832          long index;
833          final long fence;
# Line 880 | Line 882 | public final class SplittableRandom {
882      /**
883       * Spliterator for long streams.
884       */
885 <    static final class RandomLongsSpliterator implements Spliterator.OfLong {
885 >    private static final class RandomLongsSpliterator
886 >            implements Spliterator.OfLong {
887          final SplittableRandom rng;
888          long index;
889          final long fence;
# Line 936 | Line 939 | public final class SplittableRandom {
939      /**
940       * Spliterator for double streams.
941       */
942 <    static final class RandomDoublesSpliterator implements Spliterator.OfDouble {
942 >    private static final class RandomDoublesSpliterator
943 >            implements Spliterator.OfDouble {
944          final SplittableRandom rng;
945          long index;
946          final long fence;

Diff Legend

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