net.i2p.util

## Class RandomSource

- java.lang.Object
- - java.util.Random
  - - java.security.SecureRandom
    - - net.i2p.util.RandomSource

- All Implemented Interfaces:
    Serializable, EntropyHarvester
  Direct Known Subclasses:
    BufferedRandomSource, FortunaRandomSource, PooledRandomSource

      public class RandomSource
      extends SecureRandom
      implements EntropyHarvester

  Singleton for whatever PRNG i2p uses.
  Author:
    jrandom
  See Also:
    Serialized Form

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected I2PAppContext` | `_context`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `RandomSource(I2PAppContext context)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `feedEntropy(String source, byte[] data, int offset, int len)` Feed the entropy pools with data[offset:offset+len]
    `void` | `feedEntropy(String source, long data, int bitoffset, int bits)` Feed the entropy pools with the bits in the data
    `static RandomSource` | `getInstance()` Singleton for whatever PRNG i2p uses.
    `EntropyHarvester` | `harvester()`
    `boolean` | `initSeed(byte[] buf)`
    `void` | `loadSeed()`
    `static void` | `main(String[] args)`
    `int` | `nextInt(int n)` According to the java docs (http://java.sun.com/j2se/1.4.1/docs/api/java/util/Random.html#nextInt(int)) nextInt(n) should return a number between 0 and n (including 0 and excluding n).
    `long` | `nextLong(long n)` Like the modified nextInt, nextLong(n) returns a random number from 0 through n, including 0, excluding n.
    `void` | `saveSeed()`
    `static void` | `writeSeed(byte[] buf)`

    - ### Methods inherited from class java.security.SecureRandom

      `generateSeed, getAlgorithm, getInstance, getInstance, getInstance, getProvider, getSeed, next, nextBytes, setSeed, setSeed`

    - ### Methods inherited from class java.util.Random

      `nextBoolean, nextDouble, nextFloat, nextGaussian, nextInt, nextLong`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### _context

          protected final I2PAppContext _context

  - ### Constructor Detail

    - #### RandomSource

          public RandomSource(I2PAppContext context)

  - ### Method Detail

    - #### getInstance

          public static RandomSource getInstance()

      Singleton for whatever PRNG i2p uses. Same as I2PAppContext.getGlobalContext().random(); use context.random() if you have a context already.
      Returns:
        I2PAppContext.getGlobalContext().random()

    - #### nextInt

          public int nextInt(int n)

      According to the java docs (http://java.sun.com/j2se/1.4.1/docs/api/java/util/Random.html#nextInt(int)) nextInt(n) should return a number between 0 and n (including 0 and excluding n). However, their pseudocode, as well as sun's, kaffe's, and classpath's implementation INCLUDES NEGATIVE VALUES. WTF. Ok, so we're going to have it return between 0 and n (including 0, excluding n), since thats what it has been used for.
      Overrides:
        `nextInt` in class `Random`

    - #### nextLong

          public long nextLong(long n)

      Like the modified nextInt, nextLong(n) returns a random number from 0 through n, including 0, excluding n.

    - #### harvester

          public EntropyHarvester harvester()

    - #### feedEntropy

          public void feedEntropy(String source,
                         long data,
                         int bitoffset,
                         int bits)

      Description copied from interface: `EntropyHarvester`
      Feed the entropy pools with the bits in the data
      Specified by:
        `feedEntropy` in interface `EntropyHarvester`
      Parameters:
        `source` - origin of the entropy, allowing the harvester to determine how much to value the data
        `bitoffset` - bit index into the data array to start (using java standard big-endian)
        `bits` - how many bits to use

    - #### feedEntropy

          public void feedEntropy(String source,
                         byte[] data,
                         int offset,
                         int len)

      Description copied from interface: `EntropyHarvester`
      Feed the entropy pools with data[offset:offset+len]
      Specified by:
        `feedEntropy` in interface `EntropyHarvester`
      Parameters:
        `source` - origin of the entropy, allowing the harvester to determine how much to value the data
        `offset` - index into the data array to start
        `len` - how many bytes to use

    - #### loadSeed

          public void loadSeed()

    - #### saveSeed

          public void saveSeed()

    - #### writeSeed

          public static final void writeSeed(byte[] buf)

    - #### initSeed

          public final boolean initSeed(byte[] buf)

    - #### main

          public static void main(String[] args)