vendor/rand/src/deprecated.rs

   1 // Copyright 2018 Developers of the Rand project.
   2 //
   3 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   4 // https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   5 // <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
   6 // option. This file may not be copied, modified, or distributed
   7 // except according to those terms.
   8
   9 //! Deprecated re-exports (we can't add deprecation warnings otherwise)
  10
  11 #![allow(deprecated)]
  12
  13 use rngs;
  14 use {RngCore, CryptoRng, SeedableRng, Error};
  15 use rand_core::block::BlockRngCore;
  16 use rand_isaac;
  17 use rand_chacha;
  18 use rand_hc;
  19
  20 #[cfg(feature="std")]
  21 use std::io::Read;
  22
  23 #[derive(Clone, Debug)]
  24 #[deprecated(since="0.6.0",
  25     note="import from rand_isaac crate instead, or use the newer Hc128Rng")]
  26 pub struct IsaacRng(rand_isaac::IsaacRng);
  27
  28 impl RngCore for IsaacRng {
  29     #[inline(always)]
  30     fn next_u32(&mut self) -> u32 {
  31         self.0.next_u32()
  32     }
  33
  34     #[inline(always)]
  35     fn next_u64(&mut self) -> u64 {
  36         self.0.next_u64()
  37     }
  38
  39     #[inline(always)]
  40     fn fill_bytes(&mut self, dest: &mut [u8]) {
  41         self.0.fill_bytes(dest);
  42     }
  43
  44     #[inline(always)]
  45     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
  46         self.0.try_fill_bytes(dest)
  47     }
  48 }
  49
  50 impl SeedableRng for IsaacRng {
  51     type Seed = <rand_isaac::IsaacRng as SeedableRng>::Seed;
  52
  53     fn from_seed(seed: Self::Seed) -> Self {
  54         IsaacRng(rand_isaac::IsaacRng::from_seed(seed))
  55     }
  56
  57     fn from_rng<R: RngCore>(rng: R) -> Result<Self, Error> {
  58         rand_isaac::IsaacRng::from_rng(rng).map(IsaacRng)
  59     }
  60 }
  61
  62 impl IsaacRng {
  63     pub fn new_from_u64(seed: u64) -> Self {
  64         IsaacRng(rand_isaac::IsaacRng::new_from_u64(seed))
  65     }
  66 }
  67
  68
  69 #[derive(Clone, Debug)]
  70 #[deprecated(since="0.6.0",
  71     note="import from rand_isaac crate instead, or use newer Hc128Rng")]
  72 pub struct Isaac64Rng(rand_isaac::Isaac64Rng);
  73
  74 impl RngCore for Isaac64Rng {
  75     #[inline(always)]
  76     fn next_u32(&mut self) -> u32 {
  77         self.0.next_u32()
  78     }
  79
  80     #[inline(always)]
  81     fn next_u64(&mut self) -> u64 {
  82         self.0.next_u64()
  83     }
  84
  85     #[inline(always)]
  86     fn fill_bytes(&mut self, dest: &mut [u8]) {
  87         self.0.fill_bytes(dest);
  88     }
  89
  90     #[inline(always)]
  91     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
  92         self.0.try_fill_bytes(dest)
  93     }
  94 }
  95
  96 impl SeedableRng for Isaac64Rng {
  97     type Seed = <rand_isaac::Isaac64Rng as SeedableRng>::Seed;
  98
  99     fn from_seed(seed: Self::Seed) -> Self {
 100         Isaac64Rng(rand_isaac::Isaac64Rng::from_seed(seed))
 101     }
 102
 103     fn from_rng<R: RngCore>(rng: R) -> Result<Self, Error> {
 104         rand_isaac::Isaac64Rng::from_rng(rng).map(Isaac64Rng)
 105     }
 106 }
 107
 108 impl Isaac64Rng {
 109     pub fn new_from_u64(seed: u64) -> Self {
 110         Isaac64Rng(rand_isaac::Isaac64Rng::new_from_u64(seed))
 111     }
 112 }
 113
 114
 115 #[derive(Clone, Debug)]
 116 #[deprecated(since="0.6.0", note="import from rand_chacha crate instead")]
 117 pub struct ChaChaRng(rand_chacha::ChaChaRng);
 118
 119 impl RngCore for ChaChaRng {
 120     #[inline(always)]
 121     fn next_u32(&mut self) -> u32 {
 122         self.0.next_u32()
 123     }
 124
 125     #[inline(always)]
 126     fn next_u64(&mut self) -> u64 {
 127         self.0.next_u64()
 128     }
 129
 130     #[inline(always)]
 131     fn fill_bytes(&mut self, dest: &mut [u8]) {
 132         self.0.fill_bytes(dest);
 133     }
 134
 135     #[inline(always)]
 136     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
 137         self.0.try_fill_bytes(dest)
 138     }
 139 }
 140
 141 impl SeedableRng for ChaChaRng {
 142     type Seed = <rand_chacha::ChaChaRng as SeedableRng>::Seed;
 143
 144     fn from_seed(seed: Self::Seed) -> Self {
 145         ChaChaRng(rand_chacha::ChaChaRng::from_seed(seed))
 146     }
 147
 148     fn from_rng<R: RngCore>(rng: R) -> Result<Self, Error> {
 149         rand_chacha::ChaChaRng::from_rng(rng).map(ChaChaRng)
 150     }
 151 }
 152
 153 impl ChaChaRng {
 154     #[cfg(all(rustc_1_26, not(target_os = "emscripten")))]
 155     pub fn get_word_pos(&self) -> u128 {
 156         self.0.get_word_pos()
 157     }
 158
 159     #[cfg(all(rustc_1_26, not(target_os = "emscripten")))]
 160     pub fn set_word_pos(&mut self, word_offset: u128) {
 161         self.0.set_word_pos(word_offset)
 162     }
 163
 164     pub fn set_stream(&mut self, stream: u64) {
 165         self.0.set_stream(stream)
 166     }
 167 }
 168
 169 impl CryptoRng for ChaChaRng {}
 170
 171
 172 #[derive(Clone, Debug)]
 173 #[deprecated(since="0.6.0", note="import from rand_hc crate instead")]
 174 pub struct Hc128Rng(rand_hc::Hc128Rng);
 175
 176 impl RngCore for Hc128Rng {
 177     #[inline(always)]
 178     fn next_u32(&mut self) -> u32 {
 179         self.0.next_u32()
 180     }
 181
 182     #[inline(always)]
 183     fn next_u64(&mut self) -> u64 {
 184         self.0.next_u64()
 185     }
 186
 187     #[inline(always)]
 188     fn fill_bytes(&mut self, dest: &mut [u8]) {
 189         self.0.fill_bytes(dest);
 190     }
 191
 192     #[inline(always)]
 193     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
 194         self.0.try_fill_bytes(dest)
 195     }
 196 }
 197
 198 impl SeedableRng for Hc128Rng {
 199     type Seed = <rand_hc::Hc128Rng as SeedableRng>::Seed;
 200
 201     fn from_seed(seed: Self::Seed) -> Self {
 202         Hc128Rng(rand_hc::Hc128Rng::from_seed(seed))
 203     }
 204
 205     fn from_rng<R: RngCore>(rng: R) -> Result<Self, Error> {
 206         rand_hc::Hc128Rng::from_rng(rng).map(Hc128Rng)
 207     }
 208 }
 209
 210 impl CryptoRng for Hc128Rng {}
 211
 212
 213 #[derive(Clone, Debug)]
 214 #[deprecated(since="0.6.0", note="import from rand_xorshift crate instead")]
 215 pub struct XorShiftRng(::rand_xorshift::XorShiftRng);
 216
 217 impl RngCore for XorShiftRng {
 218     #[inline(always)]
 219     fn next_u32(&mut self) -> u32 {
 220         self.0.next_u32()
 221     }
 222
 223     #[inline(always)]
 224     fn next_u64(&mut self) -> u64 {
 225         self.0.next_u64()
 226     }
 227
 228     #[inline(always)]
 229     fn fill_bytes(&mut self, dest: &mut [u8]) {
 230         self.0.fill_bytes(dest);
 231     }
 232
 233     #[inline(always)]
 234     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
 235         self.0.try_fill_bytes(dest)
 236     }
 237 }
 238
 239 impl SeedableRng for XorShiftRng {
 240     type Seed = <::rand_xorshift::XorShiftRng as SeedableRng>::Seed;
 241
 242     fn from_seed(seed: Self::Seed) -> Self {
 243         XorShiftRng(::rand_xorshift::XorShiftRng::from_seed(seed))
 244     }
 245
 246     fn from_rng<R: RngCore>(rng: R) -> Result<Self, Error> {
 247         ::rand_xorshift::XorShiftRng::from_rng(rng).map(XorShiftRng)
 248     }
 249 }
 250
 251
 252 #[derive(Clone, Debug)]
 253 #[deprecated(since="0.6.0",
 254     note="import with rand::prelude::* or rand::rngs::StdRng instead")]
 255 pub struct StdRng(rngs::StdRng);
 256
 257 impl RngCore for StdRng {
 258     #[inline(always)]
 259     fn next_u32(&mut self) -> u32 {
 260         self.0.next_u32()
 261     }
 262
 263     #[inline(always)]
 264     fn next_u64(&mut self) -> u64 {
 265         self.0.next_u64()
 266     }
 267
 268     #[inline(always)]
 269     fn fill_bytes(&mut self, dest: &mut [u8]) {
 270         self.0.fill_bytes(dest);
 271     }
 272
 273     #[inline(always)]
 274     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
 275         self.0.try_fill_bytes(dest)
 276     }
 277 }
 278
 279 impl SeedableRng for StdRng {
 280     type Seed = <rngs::StdRng as SeedableRng>::Seed;
 281
 282     fn from_seed(seed: Self::Seed) -> Self {
 283         StdRng(rngs::StdRng::from_seed(seed))
 284     }
 285
 286     fn from_rng<R: RngCore>(rng: R) -> Result<Self, Error> {
 287         rngs::StdRng::from_rng(rng).map(StdRng)
 288     }
 289 }
 290
 291 impl CryptoRng for StdRng {}
 292
 293
 294 #[cfg(feature="rand_os")]
 295 #[derive(Clone, Debug)]
 296 #[deprecated(since="0.6.0", note="import with rand::rngs::OsRng instead")]
 297 pub struct OsRng(rngs::OsRng);
 298
 299 #[cfg(feature="rand_os")]
 300 impl RngCore for OsRng {
 301     #[inline(always)]
 302     fn next_u32(&mut self) -> u32 {
 303         self.0.next_u32()
 304     }
 305
 306     #[inline(always)]
 307     fn next_u64(&mut self) -> u64 {
 308         self.0.next_u64()
 309     }
 310
 311     #[inline(always)]
 312     fn fill_bytes(&mut self, dest: &mut [u8]) {
 313         self.0.fill_bytes(dest);
 314     }
 315
 316     #[inline(always)]
 317     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
 318         self.0.try_fill_bytes(dest)
 319     }
 320 }
 321
 322 #[cfg(feature="rand_os")]
 323 impl OsRng {
 324     pub fn new() -> Result<Self, Error> {
 325         rngs::OsRng::new().map(OsRng)
 326     }
 327 }
 328
 329 #[cfg(feature="rand_os")]
 330 impl CryptoRng for OsRng {}
 331
 332
 333 #[cfg(feature="std")]
 334 #[derive(Debug)]
 335 #[deprecated(since="0.6.0", note="import with rand::rngs::EntropyRng instead")]
 336 pub struct EntropyRng(rngs::EntropyRng);
 337
 338 #[cfg(feature="std")]
 339 impl RngCore for EntropyRng {
 340     #[inline(always)]
 341     fn next_u32(&mut self) -> u32 {
 342         self.0.next_u32()
 343     }
 344
 345     #[inline(always)]
 346     fn next_u64(&mut self) -> u64 {
 347         self.0.next_u64()
 348     }
 349
 350     #[inline(always)]
 351     fn fill_bytes(&mut self, dest: &mut [u8]) {
 352         self.0.fill_bytes(dest);
 353     }
 354
 355     #[inline(always)]
 356     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
 357         self.0.try_fill_bytes(dest)
 358     }
 359 }
 360
 361 #[cfg(feature="std")]
 362 impl EntropyRng {
 363     pub fn new() -> Self {
 364         EntropyRng(rngs::EntropyRng::new())
 365     }
 366 }
 367
 368 #[cfg(feature="std")]
 369 impl Default for EntropyRng {
 370     fn default() -> Self {
 371         EntropyRng::new()
 372     }
 373 }
 374
 375 #[cfg(feature="std")]
 376 impl CryptoRng for EntropyRng {}
 377
 378
 379 #[derive(Clone, Debug)]
 380 #[deprecated(since="0.6.0", note="import with rand::rngs::JitterRng instead")]
 381 pub struct JitterRng(rngs::JitterRng);
 382
 383 impl RngCore for JitterRng {
 384     #[inline(always)]
 385     fn next_u32(&mut self) -> u32 {
 386         self.0.next_u32()
 387     }
 388
 389     #[inline(always)]
 390     fn next_u64(&mut self) -> u64 {
 391         self.0.next_u64()
 392     }
 393
 394     #[inline(always)]
 395     fn fill_bytes(&mut self, dest: &mut [u8]) {
 396         self.0.fill_bytes(dest);
 397     }
 398
 399     #[inline(always)]
 400     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
 401         self.0.try_fill_bytes(dest)
 402     }
 403 }
 404
 405 impl JitterRng {
 406     #[cfg(all(feature="std", not(target_arch = "wasm32")))]
 407     pub fn new() -> Result<JitterRng, rngs::TimerError> {
 408         rngs::JitterRng::new().map(JitterRng)
 409     }
 410
 411     pub fn new_with_timer(timer: fn() -> u64) -> JitterRng {
 412         JitterRng(rngs::JitterRng::new_with_timer(timer))
 413     }
 414
 415     pub fn set_rounds(&mut self, rounds: u8) {
 416         self.0.set_rounds(rounds)
 417     }
 418
 419     pub fn test_timer(&mut self) -> Result<u8, rngs::TimerError> {
 420         self.0.test_timer()
 421     }
 422
 423     #[cfg(feature="std")]
 424     pub fn timer_stats(&mut self, var_rounds: bool) -> i64 {
 425         self.0.timer_stats(var_rounds)
 426     }
 427 }
 428
 429 impl CryptoRng for JitterRng {}
 430
 431
 432 #[cfg(feature="std")]
 433 #[derive(Clone, Debug)]
 434 #[deprecated(since="0.6.0",
 435     note="import with rand::prelude::* or rand::rngs::ThreadRng instead")]
 436 pub struct ThreadRng(rngs::ThreadRng);
 437
 438 #[cfg(feature="std")]
 439 impl RngCore for ThreadRng {
 440     #[inline(always)]
 441     fn next_u32(&mut self) -> u32 {
 442         self.0.next_u32()
 443     }
 444
 445     #[inline(always)]
 446     fn next_u64(&mut self) -> u64 {
 447         self.0.next_u64()
 448     }
 449
 450     #[inline(always)]
 451     fn fill_bytes(&mut self, dest: &mut [u8]) {
 452         self.0.fill_bytes(dest);
 453     }
 454
 455     #[inline(always)]
 456     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
 457         self.0.try_fill_bytes(dest)
 458     }
 459 }
 460
 461 #[cfg(feature="std")]
 462 impl CryptoRng for ThreadRng {}
 463
 464
 465 #[cfg(feature="std")]
 466 #[derive(Debug)]
 467 #[deprecated(since="0.6.0", note="import with rand::rngs::adapter::ReadRng instead")]
 468 pub struct ReadRng<R>(rngs::adapter::ReadRng<R>);
 469
 470 #[cfg(feature="std")]
 471 impl<R: Read> RngCore for ReadRng<R> {
 472     #[inline(always)]
 473     fn next_u32(&mut self) -> u32 {
 474         self.0.next_u32()
 475     }
 476
 477     #[inline(always)]
 478     fn next_u64(&mut self) -> u64 {
 479         self.0.next_u64()
 480     }
 481
 482     #[inline(always)]
 483     fn fill_bytes(&mut self, dest: &mut [u8]) {
 484         self.0.fill_bytes(dest);
 485     }
 486
 487     #[inline(always)]
 488     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
 489         self.0.try_fill_bytes(dest)
 490     }
 491 }
 492
 493 #[cfg(feature="std")]
 494 impl<R: Read> ReadRng<R> {
 495     pub fn new(r: R) -> ReadRng<R> {
 496         ReadRng(rngs::adapter::ReadRng::new(r))
 497     }
 498 }
 499
 500
 501 #[derive(Clone, Debug)]
 502 pub struct ReseedingRng<R, Rsdr>(rngs::adapter::ReseedingRng<R, Rsdr>)
 503 where R: BlockRngCore + SeedableRng,
 504       Rsdr: RngCore;
 505
 506 impl<R, Rsdr: RngCore> RngCore for ReseedingRng<R, Rsdr>
 507 where R: BlockRngCore<Item = u32> + SeedableRng,
 508     <R as BlockRngCore>::Results: AsRef<[u32]> + AsMut<[u32]>
 509 {
 510     #[inline(always)]
 511     fn next_u32(&mut self) -> u32 {
 512         self.0.next_u32()
 513     }
 514
 515     #[inline(always)]
 516     fn next_u64(&mut self) -> u64 {
 517         self.0.next_u64()
 518     }
 519
 520     fn fill_bytes(&mut self, dest: &mut [u8]) {
 521         self.0.fill_bytes(dest)
 522     }
 523
 524     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
 525         self.0.try_fill_bytes(dest)
 526     }
 527 }
 528
 529 impl<R, Rsdr> ReseedingRng<R, Rsdr>
 530 where R: BlockRngCore + SeedableRng,
 531       Rsdr: RngCore
 532 {
 533     pub fn new(rng: R, threshold: u64, reseeder: Rsdr) -> Self {
 534         ReseedingRng(rngs::adapter::ReseedingRng::new(rng, threshold, reseeder))
 535     }
 536
 537     pub fn reseed(&mut self) -> Result<(), Error> {
 538         self.0.reseed()
 539     }
 540 }
 541
 542 impl<R, Rsdr> CryptoRng for ReseedingRng<R, Rsdr>
 543 where R: BlockRngCore + SeedableRng + CryptoRng,
 544       Rsdr: RngCore + CryptoRng {}