src/deprecated.rs - third_party/rust-mirrors/rand - Git at Google

 // Copyright 2018 Developers of the Rand project.
 //
 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
 // https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
 // <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.

 //! Deprecated re-exports (we can't add deprecation warnings otherwise)

 #![allow(deprecated)]

 use rngs;
 use {RngCore, CryptoRng, SeedableRng, Error};
 use rand_core::block::BlockRngCore;
 use rand_isaac;
 use rand_chacha;
 use rand_hc;

 #[cfg(feature="std")]
 use std::io::Read;

 #[derive(Clone, Debug)]
 #[deprecated(since="0.6.0",
     note="import from rand_isaac crate instead, or use the newer Hc128Rng")]
 pub struct IsaacRng(rand_isaac::IsaacRng);

 impl RngCore for IsaacRng {
     #[inline(always)]
     fn next_u32(&mut self) -> u32 {
         self.0.next_u32()
     }

     #[inline(always)]
     fn next_u64(&mut self) -> u64 {
         self.0.next_u64()
     }

     #[inline(always)]
     fn fill_bytes(&mut self, dest: &mut [u8]) {
         self.0.fill_bytes(dest);
     }

     #[inline(always)]
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
         self.0.try_fill_bytes(dest)
     }
 }

 impl SeedableRng for IsaacRng {
     type Seed = <rand_isaac::IsaacRng as SeedableRng>::Seed;

     fn from_seed(seed: Self::Seed) -> Self {
         IsaacRng(rand_isaac::IsaacRng::from_seed(seed))
     }

     fn from_rng<R: RngCore>(rng: R) -> Result<Self, Error> {
         rand_isaac::IsaacRng::from_rng(rng).map(IsaacRng)
     }
 }

 impl IsaacRng {
     pub fn new_from_u64(seed: u64) -> Self {
         IsaacRng(rand_isaac::IsaacRng::new_from_u64(seed))
     }
 }


 #[derive(Clone, Debug)]
 #[deprecated(since="0.6.0",
     note="import from rand_isaac crate instead, or use newer Hc128Rng")]
 pub struct Isaac64Rng(rand_isaac::Isaac64Rng);

 impl RngCore for Isaac64Rng {
     #[inline(always)]
     fn next_u32(&mut self) -> u32 {
         self.0.next_u32()
     }

     #[inline(always)]
     fn next_u64(&mut self) -> u64 {
         self.0.next_u64()
     }

     #[inline(always)]
     fn fill_bytes(&mut self, dest: &mut [u8]) {
         self.0.fill_bytes(dest);
     }

     #[inline(always)]
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
         self.0.try_fill_bytes(dest)
     }
 }

 impl SeedableRng for Isaac64Rng {
     type Seed = <rand_isaac::Isaac64Rng as SeedableRng>::Seed;

     fn from_seed(seed: Self::Seed) -> Self {
         Isaac64Rng(rand_isaac::Isaac64Rng::from_seed(seed))
     }

     fn from_rng<R: RngCore>(rng: R) -> Result<Self, Error> {
         rand_isaac::Isaac64Rng::from_rng(rng).map(Isaac64Rng)
     }
 }

 impl Isaac64Rng {
     pub fn new_from_u64(seed: u64) -> Self {
         Isaac64Rng(rand_isaac::Isaac64Rng::new_from_u64(seed))
     }
 }


 #[derive(Clone, Debug)]
 #[deprecated(since="0.6.0", note="import from rand_chacha crate instead")]
 pub struct ChaChaRng(rand_chacha::ChaChaRng);

 impl RngCore for ChaChaRng {
     #[inline(always)]
     fn next_u32(&mut self) -> u32 {
         self.0.next_u32()
     }

     #[inline(always)]
     fn next_u64(&mut self) -> u64 {
         self.0.next_u64()
     }

     #[inline(always)]
     fn fill_bytes(&mut self, dest: &mut [u8]) {
         self.0.fill_bytes(dest);
     }

     #[inline(always)]
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
         self.0.try_fill_bytes(dest)
     }
 }

 impl SeedableRng for ChaChaRng {
     type Seed = <rand_chacha::ChaChaRng as SeedableRng>::Seed;

     fn from_seed(seed: Self::Seed) -> Self {
         ChaChaRng(rand_chacha::ChaChaRng::from_seed(seed))
     }

     fn from_rng<R: RngCore>(rng: R) -> Result<Self, Error> {
         rand_chacha::ChaChaRng::from_rng(rng).map(ChaChaRng)
     }
 }

 impl ChaChaRng {
     #[cfg(all(rustc_1_26, not(target_os = "emscripten")))]
     pub fn get_word_pos(&self) -> u128 {
         self.0.get_word_pos()
     }

     #[cfg(all(rustc_1_26, not(target_os = "emscripten")))]
     pub fn set_word_pos(&mut self, word_offset: u128) {
         self.0.set_word_pos(word_offset)
     }

     pub fn set_stream(&mut self, stream: u64) {
         self.0.set_stream(stream)
     }
 }

 impl CryptoRng for ChaChaRng {}


 #[derive(Clone, Debug)]
 #[deprecated(since="0.6.0", note="import from rand_hc crate instead")]
 pub struct Hc128Rng(rand_hc::Hc128Rng);

 impl RngCore for Hc128Rng {
     #[inline(always)]
     fn next_u32(&mut self) -> u32 {
         self.0.next_u32()
     }

     #[inline(always)]
     fn next_u64(&mut self) -> u64 {
         self.0.next_u64()
     }

     #[inline(always)]
     fn fill_bytes(&mut self, dest: &mut [u8]) {
         self.0.fill_bytes(dest);
     }

     #[inline(always)]
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
         self.0.try_fill_bytes(dest)
     }
 }

 impl SeedableRng for Hc128Rng {
     type Seed = <rand_hc::Hc128Rng as SeedableRng>::Seed;

     fn from_seed(seed: Self::Seed) -> Self {
         Hc128Rng(rand_hc::Hc128Rng::from_seed(seed))
     }

     fn from_rng<R: RngCore>(rng: R) -> Result<Self, Error> {
         rand_hc::Hc128Rng::from_rng(rng).map(Hc128Rng)
     }
 }

 impl CryptoRng for Hc128Rng {}


 #[derive(Clone, Debug)]
 #[deprecated(since="0.6.0", note="import from rand_xorshift crate instead")]
 pub struct XorShiftRng(::rand_xorshift::XorShiftRng);

 impl RngCore for XorShiftRng {
     #[inline(always)]
     fn next_u32(&mut self) -> u32 {
         self.0.next_u32()
     }

     #[inline(always)]
     fn next_u64(&mut self) -> u64 {
         self.0.next_u64()
     }

     #[inline(always)]
     fn fill_bytes(&mut self, dest: &mut [u8]) {
         self.0.fill_bytes(dest);
     }

     #[inline(always)]
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
         self.0.try_fill_bytes(dest)
     }
 }

 impl SeedableRng for XorShiftRng {
     type Seed = <::rand_xorshift::XorShiftRng as SeedableRng>::Seed;

     fn from_seed(seed: Self::Seed) -> Self {
         XorShiftRng(::rand_xorshift::XorShiftRng::from_seed(seed))
     }

     fn from_rng<R: RngCore>(rng: R) -> Result<Self, Error> {
         ::rand_xorshift::XorShiftRng::from_rng(rng).map(XorShiftRng)
     }
 }


 #[derive(Clone, Debug)]
 #[deprecated(since="0.6.0",
     note="import with rand::prelude::* or rand::rngs::StdRng instead")]
 pub struct StdRng(rngs::StdRng);

 impl RngCore for StdRng {
     #[inline(always)]
     fn next_u32(&mut self) -> u32 {
         self.0.next_u32()
     }

     #[inline(always)]
     fn next_u64(&mut self) -> u64 {
         self.0.next_u64()
     }

     #[inline(always)]
     fn fill_bytes(&mut self, dest: &mut [u8]) {
         self.0.fill_bytes(dest);
     }

     #[inline(always)]
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
         self.0.try_fill_bytes(dest)
     }
 }

 impl SeedableRng for StdRng {
     type Seed = <rngs::StdRng as SeedableRng>::Seed;

     fn from_seed(seed: Self::Seed) -> Self {
         StdRng(rngs::StdRng::from_seed(seed))
     }

     fn from_rng<R: RngCore>(rng: R) -> Result<Self, Error> {
         rngs::StdRng::from_rng(rng).map(StdRng)
     }
 }

 impl CryptoRng for StdRng {}


 #[cfg(feature="rand_os")]
 #[derive(Clone, Debug)]
 #[deprecated(since="0.6.0", note="import with rand::rngs::OsRng instead")]
 pub struct OsRng(rngs::OsRng);

 #[cfg(feature="rand_os")]
 impl RngCore for OsRng {
     #[inline(always)]
     fn next_u32(&mut self) -> u32 {
         self.0.next_u32()
     }

     #[inline(always)]
     fn next_u64(&mut self) -> u64 {
         self.0.next_u64()
     }

     #[inline(always)]
     fn fill_bytes(&mut self, dest: &mut [u8]) {
         self.0.fill_bytes(dest);
     }

     #[inline(always)]
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
         self.0.try_fill_bytes(dest)
     }
 }

 #[cfg(feature="rand_os")]
 impl OsRng {
     pub fn new() -> Result<Self, Error> {
         rngs::OsRng::new().map(OsRng)
     }
 }

 #[cfg(feature="rand_os")]
 impl CryptoRng for OsRng {}


 #[cfg(feature="std")]
 #[derive(Debug)]
 #[deprecated(since="0.6.0", note="import with rand::rngs::EntropyRng instead")]
 pub struct EntropyRng(rngs::EntropyRng);

 #[cfg(feature="std")]
 impl RngCore for EntropyRng {
     #[inline(always)]
     fn next_u32(&mut self) -> u32 {
         self.0.next_u32()
     }

     #[inline(always)]
     fn next_u64(&mut self) -> u64 {
         self.0.next_u64()
     }

     #[inline(always)]
     fn fill_bytes(&mut self, dest: &mut [u8]) {
         self.0.fill_bytes(dest);
     }

     #[inline(always)]
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
         self.0.try_fill_bytes(dest)
     }
 }

 #[cfg(feature="std")]
 impl EntropyRng {
     pub fn new() -> Self {
         EntropyRng(rngs::EntropyRng::new())
     }
 }

 #[cfg(feature="std")]
 impl Default for EntropyRng {
     fn default() -> Self {
         EntropyRng::new()
     }
 }

 #[cfg(feature="std")]
 impl CryptoRng for EntropyRng {}


 #[derive(Clone, Debug)]
 #[deprecated(since="0.6.0", note="import with rand::rngs::JitterRng instead")]
 pub struct JitterRng(rngs::JitterRng);

 impl RngCore for JitterRng {
     #[inline(always)]
     fn next_u32(&mut self) -> u32 {
         self.0.next_u32()
     }

     #[inline(always)]
     fn next_u64(&mut self) -> u64 {
         self.0.next_u64()
     }

     #[inline(always)]
     fn fill_bytes(&mut self, dest: &mut [u8]) {
         self.0.fill_bytes(dest);
     }

     #[inline(always)]
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
         self.0.try_fill_bytes(dest)
     }
 }

 impl JitterRng {
     #[cfg(all(feature="std", not(target_arch = "wasm32")))]
     pub fn new() -> Result<JitterRng, rngs::TimerError> {
         rngs::JitterRng::new().map(JitterRng)
     }

     pub fn new_with_timer(timer: fn() -> u64) -> JitterRng {
         JitterRng(rngs::JitterRng::new_with_timer(timer))
     }

     pub fn set_rounds(&mut self, rounds: u8) {
         self.0.set_rounds(rounds)
     }

     pub fn test_timer(&mut self) -> Result<u8, rngs::TimerError> {
         self.0.test_timer()
     }

     #[cfg(feature="std")]
     pub fn timer_stats(&mut self, var_rounds: bool) -> i64 {
         self.0.timer_stats(var_rounds)
     }
 }

 impl CryptoRng for JitterRng {}


 #[cfg(feature="std")]
 #[derive(Clone, Debug)]
 #[deprecated(since="0.6.0",
     note="import with rand::prelude::* or rand::rngs::ThreadRng instead")]
 pub struct ThreadRng(rngs::ThreadRng);

 #[cfg(feature="std")]
 impl RngCore for ThreadRng {
     #[inline(always)]
     fn next_u32(&mut self) -> u32 {
         self.0.next_u32()
     }

     #[inline(always)]
     fn next_u64(&mut self) -> u64 {
         self.0.next_u64()
     }

     #[inline(always)]
     fn fill_bytes(&mut self, dest: &mut [u8]) {
         self.0.fill_bytes(dest);
     }

     #[inline(always)]
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
         self.0.try_fill_bytes(dest)
     }
 }

 #[cfg(feature="std")]
 impl CryptoRng for ThreadRng {}


 #[cfg(feature="std")]
 #[derive(Debug)]
 #[deprecated(since="0.6.0", note="import with rand::rngs::adapter::ReadRng instead")]
 pub struct ReadRng<R>(rngs::adapter::ReadRng<R>);

 #[cfg(feature="std")]
 impl<R: Read> RngCore for ReadRng<R> {
     #[inline(always)]
     fn next_u32(&mut self) -> u32 {
         self.0.next_u32()
     }

     #[inline(always)]
     fn next_u64(&mut self) -> u64 {
         self.0.next_u64()
     }

     #[inline(always)]
     fn fill_bytes(&mut self, dest: &mut [u8]) {
         self.0.fill_bytes(dest);
     }

     #[inline(always)]
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
         self.0.try_fill_bytes(dest)
     }
 }

 #[cfg(feature="std")]
 impl<R: Read> ReadRng<R> {
     pub fn new(r: R) -> ReadRng<R> {
         ReadRng(rngs::adapter::ReadRng::new(r))
     }
 }


 #[derive(Clone, Debug)]
 pub struct ReseedingRng<R, Rsdr>(rngs::adapter::ReseedingRng<R, Rsdr>)
 where R: BlockRngCore + SeedableRng,
       Rsdr: RngCore;

 impl<R, Rsdr: RngCore> RngCore for ReseedingRng<R, Rsdr>
 where R: BlockRngCore<Item = u32> + SeedableRng,
     <R as BlockRngCore>::Results: AsRef<[u32]> + AsMut<[u32]>
 {
     #[inline(always)]
     fn next_u32(&mut self) -> u32 {
         self.0.next_u32()
     }

     #[inline(always)]
     fn next_u64(&mut self) -> u64 {
         self.0.next_u64()
     }

     fn fill_bytes(&mut self, dest: &mut [u8]) {
         self.0.fill_bytes(dest)
     }

     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
         self.0.try_fill_bytes(dest)
     }
 }

 impl<R, Rsdr> ReseedingRng<R, Rsdr>
 where R: BlockRngCore + SeedableRng,
       Rsdr: RngCore
 {
     pub fn new(rng: R, threshold: u64, reseeder: Rsdr) -> Self {
         ReseedingRng(rngs::adapter::ReseedingRng::new(rng, threshold, reseeder))
     }

     pub fn reseed(&mut self) -> Result<(), Error> {
         self.0.reseed()
     }
 }

 impl<R, Rsdr> CryptoRng for ReseedingRng<R, Rsdr>
 where R: BlockRngCore + SeedableRng + CryptoRng,
       Rsdr: RngCore + CryptoRng {}
	// Copyright 2018 Developers of the Rand project.
	//
	// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
	// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
	// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
	// option. This file may not be copied, modified, or distributed
	// except according to those terms.

	//! Deprecated re-exports (we can't add deprecation warnings otherwise)

	#![allow(deprecated)]

	use rngs;
	use {RngCore, CryptoRng, SeedableRng, Error};
	use rand_core::block::BlockRngCore;
	use rand_isaac;
	use rand_chacha;
	use rand_hc;

	#[cfg(feature="std")]
	use std::io::Read;

	#[derive(Clone, Debug)]
	#[deprecated(since="0.6.0",
	note="import from rand_isaac crate instead, or use the newer Hc128Rng")]
	pub struct IsaacRng(rand_isaac::IsaacRng);

	impl RngCore for IsaacRng {
	#[inline(always)]
	fn next_u32(&mut self) -> u32 {
	self.0.next_u32()
	}

	#[inline(always)]
	fn next_u64(&mut self) -> u64 {
	self.0.next_u64()
	}

	#[inline(always)]
	fn fill_bytes(&mut self, dest: &mut [u8]) {
	self.0.fill_bytes(dest);
	}

	#[inline(always)]
	fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
	self.0.try_fill_bytes(dest)
	}
	}

	impl SeedableRng for IsaacRng {
	type Seed = <rand_isaac::IsaacRng as SeedableRng>::Seed;

	fn from_seed(seed: Self::Seed) -> Self {
	IsaacRng(rand_isaac::IsaacRng::from_seed(seed))
	}

	fn from_rng<R: RngCore>(rng: R) -> Result<Self, Error> {
	rand_isaac::IsaacRng::from_rng(rng).map(IsaacRng)
	}
	}

	impl IsaacRng {
	pub fn new_from_u64(seed: u64) -> Self {
	IsaacRng(rand_isaac::IsaacRng::new_from_u64(seed))
	}
	}


	#[derive(Clone, Debug)]
	#[deprecated(since="0.6.0",
	note="import from rand_isaac crate instead, or use newer Hc128Rng")]
	pub struct Isaac64Rng(rand_isaac::Isaac64Rng);

	impl RngCore for Isaac64Rng {
	#[inline(always)]
	fn next_u32(&mut self) -> u32 {
	self.0.next_u32()
	}

	#[inline(always)]
	fn next_u64(&mut self) -> u64 {
	self.0.next_u64()
	}

	#[inline(always)]
	fn fill_bytes(&mut self, dest: &mut [u8]) {
	self.0.fill_bytes(dest);
	}

	#[inline(always)]
	fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
	self.0.try_fill_bytes(dest)
	}
	}

	impl SeedableRng for Isaac64Rng {
	type Seed = <rand_isaac::Isaac64Rng as SeedableRng>::Seed;

	fn from_seed(seed: Self::Seed) -> Self {
	Isaac64Rng(rand_isaac::Isaac64Rng::from_seed(seed))
	}

	fn from_rng<R: RngCore>(rng: R) -> Result<Self, Error> {
	rand_isaac::Isaac64Rng::from_rng(rng).map(Isaac64Rng)
	}
	}

	impl Isaac64Rng {
	pub fn new_from_u64(seed: u64) -> Self {
	Isaac64Rng(rand_isaac::Isaac64Rng::new_from_u64(seed))
	}
	}


	#[derive(Clone, Debug)]
	#[deprecated(since="0.6.0", note="import from rand_chacha crate instead")]
	pub struct ChaChaRng(rand_chacha::ChaChaRng);

	impl RngCore for ChaChaRng {
	#[inline(always)]
	fn next_u32(&mut self) -> u32 {
	self.0.next_u32()
	}

	#[inline(always)]
	fn next_u64(&mut self) -> u64 {
	self.0.next_u64()
	}

	#[inline(always)]
	fn fill_bytes(&mut self, dest: &mut [u8]) {
	self.0.fill_bytes(dest);
	}

	#[inline(always)]
	fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
	self.0.try_fill_bytes(dest)
	}
	}

	impl SeedableRng for ChaChaRng {
	type Seed = <rand_chacha::ChaChaRng as SeedableRng>::Seed;

	fn from_seed(seed: Self::Seed) -> Self {
	ChaChaRng(rand_chacha::ChaChaRng::from_seed(seed))
	}

	fn from_rng<R: RngCore>(rng: R) -> Result<Self, Error> {
	rand_chacha::ChaChaRng::from_rng(rng).map(ChaChaRng)
	}
	}

	impl ChaChaRng {
	#[cfg(all(rustc_1_26, not(target_os = "emscripten")))]
	pub fn get_word_pos(&self) -> u128 {
	self.0.get_word_pos()
	}

	#[cfg(all(rustc_1_26, not(target_os = "emscripten")))]
	pub fn set_word_pos(&mut self, word_offset: u128) {
	self.0.set_word_pos(word_offset)
	}

	pub fn set_stream(&mut self, stream: u64) {
	self.0.set_stream(stream)
	}
	}

	impl CryptoRng for ChaChaRng {}


	#[derive(Clone, Debug)]
	#[deprecated(since="0.6.0", note="import from rand_hc crate instead")]
	pub struct Hc128Rng(rand_hc::Hc128Rng);

	impl RngCore for Hc128Rng {
	#[inline(always)]
	fn next_u32(&mut self) -> u32 {
	self.0.next_u32()
	}

	#[inline(always)]
	fn next_u64(&mut self) -> u64 {
	self.0.next_u64()
	}

	#[inline(always)]
	fn fill_bytes(&mut self, dest: &mut [u8]) {
	self.0.fill_bytes(dest);
	}

	#[inline(always)]
	fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
	self.0.try_fill_bytes(dest)
	}
	}

	impl SeedableRng for Hc128Rng {
	type Seed = <rand_hc::Hc128Rng as SeedableRng>::Seed;

	fn from_seed(seed: Self::Seed) -> Self {
	Hc128Rng(rand_hc::Hc128Rng::from_seed(seed))
	}

	fn from_rng<R: RngCore>(rng: R) -> Result<Self, Error> {
	rand_hc::Hc128Rng::from_rng(rng).map(Hc128Rng)
	}
	}

	impl CryptoRng for Hc128Rng {}


	#[derive(Clone, Debug)]
	#[deprecated(since="0.6.0", note="import from rand_xorshift crate instead")]
	pub struct XorShiftRng(::rand_xorshift::XorShiftRng);

	impl RngCore for XorShiftRng {
	#[inline(always)]
	fn next_u32(&mut self) -> u32 {
	self.0.next_u32()
	}

	#[inline(always)]
	fn next_u64(&mut self) -> u64 {
	self.0.next_u64()
	}

	#[inline(always)]
	fn fill_bytes(&mut self, dest: &mut [u8]) {
	self.0.fill_bytes(dest);
	}

	#[inline(always)]
	fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
	self.0.try_fill_bytes(dest)
	}
	}

	impl SeedableRng for XorShiftRng {
	type Seed = <::rand_xorshift::XorShiftRng as SeedableRng>::Seed;

	fn from_seed(seed: Self::Seed) -> Self {
	XorShiftRng(::rand_xorshift::XorShiftRng::from_seed(seed))
	}

	fn from_rng<R: RngCore>(rng: R) -> Result<Self, Error> {
	::rand_xorshift::XorShiftRng::from_rng(rng).map(XorShiftRng)
	}
	}


	#[derive(Clone, Debug)]
	#[deprecated(since="0.6.0",
	note="import with rand::prelude::* or rand::rngs::StdRng instead")]
	pub struct StdRng(rngs::StdRng);

	impl RngCore for StdRng {
	#[inline(always)]
	fn next_u32(&mut self) -> u32 {
	self.0.next_u32()
	}

	#[inline(always)]
	fn next_u64(&mut self) -> u64 {
	self.0.next_u64()
	}

	#[inline(always)]
	fn fill_bytes(&mut self, dest: &mut [u8]) {
	self.0.fill_bytes(dest);
	}

	#[inline(always)]
	fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
	self.0.try_fill_bytes(dest)
	}
	}

	impl SeedableRng for StdRng {
	type Seed = <rngs::StdRng as SeedableRng>::Seed;

	fn from_seed(seed: Self::Seed) -> Self {
	StdRng(rngs::StdRng::from_seed(seed))
	}

	fn from_rng<R: RngCore>(rng: R) -> Result<Self, Error> {
	rngs::StdRng::from_rng(rng).map(StdRng)
	}
	}

	impl CryptoRng for StdRng {}


	#[cfg(feature="rand_os")]
	#[derive(Clone, Debug)]
	#[deprecated(since="0.6.0", note="import with rand::rngs::OsRng instead")]
	pub struct OsRng(rngs::OsRng);

	#[cfg(feature="rand_os")]
	impl RngCore for OsRng {
	#[inline(always)]
	fn next_u32(&mut self) -> u32 {
	self.0.next_u32()
	}

	#[inline(always)]
	fn next_u64(&mut self) -> u64 {
	self.0.next_u64()
	}

	#[inline(always)]
	fn fill_bytes(&mut self, dest: &mut [u8]) {
	self.0.fill_bytes(dest);
	}

	#[inline(always)]
	fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
	self.0.try_fill_bytes(dest)
	}
	}

	#[cfg(feature="rand_os")]
	impl OsRng {
	pub fn new() -> Result<Self, Error> {
	rngs::OsRng::new().map(OsRng)
	}
	}

	#[cfg(feature="rand_os")]
	impl CryptoRng for OsRng {}


	#[cfg(feature="std")]
	#[derive(Debug)]
	#[deprecated(since="0.6.0", note="import with rand::rngs::EntropyRng instead")]
	pub struct EntropyRng(rngs::EntropyRng);

	#[cfg(feature="std")]
	impl RngCore for EntropyRng {
	#[inline(always)]
	fn next_u32(&mut self) -> u32 {
	self.0.next_u32()
	}

	#[inline(always)]
	fn next_u64(&mut self) -> u64 {
	self.0.next_u64()
	}

	#[inline(always)]
	fn fill_bytes(&mut self, dest: &mut [u8]) {
	self.0.fill_bytes(dest);
	}

	#[inline(always)]
	fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
	self.0.try_fill_bytes(dest)
	}
	}

	#[cfg(feature="std")]
	impl EntropyRng {
	pub fn new() -> Self {
	EntropyRng(rngs::EntropyRng::new())
	}
	}

	#[cfg(feature="std")]
	impl Default for EntropyRng {
	fn default() -> Self {
	EntropyRng::new()
	}
	}

	#[cfg(feature="std")]
	impl CryptoRng for EntropyRng {}


	#[derive(Clone, Debug)]
	#[deprecated(since="0.6.0", note="import with rand::rngs::JitterRng instead")]
	pub struct JitterRng(rngs::JitterRng);

	impl RngCore for JitterRng {
	#[inline(always)]
	fn next_u32(&mut self) -> u32 {
	self.0.next_u32()
	}

	#[inline(always)]
	fn next_u64(&mut self) -> u64 {
	self.0.next_u64()
	}

	#[inline(always)]
	fn fill_bytes(&mut self, dest: &mut [u8]) {
	self.0.fill_bytes(dest);
	}

	#[inline(always)]
	fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
	self.0.try_fill_bytes(dest)
	}
	}

	impl JitterRng {
	#[cfg(all(feature="std", not(target_arch = "wasm32")))]
	pub fn new() -> Result<JitterRng, rngs::TimerError> {
	rngs::JitterRng::new().map(JitterRng)
	}

	pub fn new_with_timer(timer: fn() -> u64) -> JitterRng {
	JitterRng(rngs::JitterRng::new_with_timer(timer))
	}

	pub fn set_rounds(&mut self, rounds: u8) {
	self.0.set_rounds(rounds)
	}

	pub fn test_timer(&mut self) -> Result<u8, rngs::TimerError> {
	self.0.test_timer()
	}

	#[cfg(feature="std")]
	pub fn timer_stats(&mut self, var_rounds: bool) -> i64 {
	self.0.timer_stats(var_rounds)
	}
	}

	impl CryptoRng for JitterRng {}


	#[cfg(feature="std")]
	#[derive(Clone, Debug)]
	#[deprecated(since="0.6.0",
	note="import with rand::prelude::* or rand::rngs::ThreadRng instead")]
	pub struct ThreadRng(rngs::ThreadRng);

	#[cfg(feature="std")]
	impl RngCore for ThreadRng {
	#[inline(always)]
	fn next_u32(&mut self) -> u32 {
	self.0.next_u32()
	}

	#[inline(always)]
	fn next_u64(&mut self) -> u64 {
	self.0.next_u64()
	}

	#[inline(always)]
	fn fill_bytes(&mut self, dest: &mut [u8]) {
	self.0.fill_bytes(dest);
	}

	#[inline(always)]
	fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
	self.0.try_fill_bytes(dest)
	}
	}

	#[cfg(feature="std")]
	impl CryptoRng for ThreadRng {}


	#[cfg(feature="std")]
	#[derive(Debug)]
	#[deprecated(since="0.6.0", note="import with rand::rngs::adapter::ReadRng instead")]
	pub struct ReadRng<R>(rngs::adapter::ReadRng<R>);

	#[cfg(feature="std")]
	impl<R: Read> RngCore for ReadRng<R> {
	#[inline(always)]
	fn next_u32(&mut self) -> u32 {
	self.0.next_u32()
	}

	#[inline(always)]
	fn next_u64(&mut self) -> u64 {
	self.0.next_u64()
	}

	#[inline(always)]
	fn fill_bytes(&mut self, dest: &mut [u8]) {
	self.0.fill_bytes(dest);
	}

	#[inline(always)]
	fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
	self.0.try_fill_bytes(dest)
	}
	}

	#[cfg(feature="std")]
	impl<R: Read> ReadRng<R> {
	pub fn new(r: R) -> ReadRng<R> {
	ReadRng(rngs::adapter::ReadRng::new(r))
	}
	}


	#[derive(Clone, Debug)]
	pub struct ReseedingRng<R, Rsdr>(rngs::adapter::ReseedingRng<R, Rsdr>)
	where R: BlockRngCore + SeedableRng,
	Rsdr: RngCore;

	impl<R, Rsdr: RngCore> RngCore for ReseedingRng<R, Rsdr>
	where R: BlockRngCore<Item = u32> + SeedableRng,
	<R as BlockRngCore>::Results: AsRef<[u32]> + AsMut<[u32]>
	{
	#[inline(always)]
	fn next_u32(&mut self) -> u32 {
	self.0.next_u32()
	}

	#[inline(always)]
	fn next_u64(&mut self) -> u64 {
	self.0.next_u64()
	}

	fn fill_bytes(&mut self, dest: &mut [u8]) {
	self.0.fill_bytes(dest)
	}

	fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
	self.0.try_fill_bytes(dest)
	}
	}

	impl<R, Rsdr> ReseedingRng<R, Rsdr>
	where R: BlockRngCore + SeedableRng,
	Rsdr: RngCore
	{
	pub fn new(rng: R, threshold: u64, reseeder: Rsdr) -> Self {
	ReseedingRng(rngs::adapter::ReseedingRng::new(rng, threshold, reseeder))
	}

	pub fn reseed(&mut self) -> Result<(), Error> {
	self.0.reseed()
	}
	}

	impl<R, Rsdr> CryptoRng for ReseedingRng<R, Rsdr>
	where R: BlockRngCore + SeedableRng + CryptoRng,
	Rsdr: RngCore + CryptoRng {}