Update the random_device implementation so that it:

* Supports more platforms optimally, for example CloudABI, OpenBSD, and Windows UWP
* Is easier to maintain as each platform's implementation is in a separate file
* Removes the library dependency on Boost.System
* Is header-only, and thus makes Boost.Random header-only
* Is well-tested for happy and sad paths

Removes the token-based random_device explicit constructor.

Adds a new exception "entropy_error" to handle errors getting entropy.

Removed the detail auto_link implementation inside Boost.Random as it is no longer
necessary - the one in Boost.Config is sufficient.

Also added a top-level Jamfile that builds the example subdirectory with each
build, as one of the examples needed to be updated in order to build.  This will
prevent rot in the example directory.

Note: Other libraries that link against Boost.Random (like Boost.Uuid) will fail
to build until they stop trying to link against Boost.Random.

This fixes boostorg#20
This fixes boostorg#22

.gitignore

@@ -1,3 +1,3 @@
 /doc/html
 /doc/reference.xml
-/test/rng.saved
+**/rng.saved

Jamfile

@@ -0,0 +1,30 @@
+#  Boost.Random Library Jamfile
+#
+#  Copyright (c) 2017 James E. King, III
+#
+#  Use, modification, and distribution are subject to the
+#  Boost Software License, Version 1.0. (See accompanying file
+#  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+project libs/random
+    : requirements
+
+      <warnings>all
+
+      <toolset>clang:<cxxflags>-Wextra
+      <toolset>clang:<cxxflags>-ansi
+#     <toolset>clang:<cxxflags>-pedantic
+      <toolset>clang:<cxxflags>-Wno-c++11-long-long
+
+      <toolset>gcc:<cxxflags>-Wextra
+      <toolset>gcc:<cxxflags>-ansi
+#     <toolset>gcc:<cxxflags>-pedantic
+      <toolset>gcc:<cxxflags>-Wno-long-long
+    ;
+
+# pedantic mode disabled due to issue in multiprecision
+# https://github.com/boostorg/multiprecision/issues/34
+
+# please order by name to ease maintenance
+build-project example ;
+build-project test ;

doc/random.qbk

@@ -107,14 +107,32 @@ You should read the [concepts concepts documentation] for an introduction and th
 definition of the basic concepts. For a quick start, it may be sufficient
 to have a look at [@boost:/libs/random/example/random_demo.cpp random_demo.cpp].
 
-For a very quick start, here's an example:
+For a very quick start, here's an example for rolling one die:
 
-  ``[classref boost::random::mt19937]`` rng;         // produces randomness out of thin air
-                                      // see pseudo-random number generators
+  ``[classref boost::random::random_device]`` entropy; // operating-system provided entropy generator
   ``[classref boost::random::uniform_int_distribution]<>`` six(1,6);
-                                      // distribution that maps to 1..6
-                                      // see random number distributions
-  int x = six(rng);                   // simulate rolling a die
+                                        // distribution that maps to 1..6
+                                        // see random number distributions
+  int x = six(entropy);                 // simulate rolling a die
+
+If you are going to be rolling a large number of dies, you can initialize a
+__PseudoRandomNumberGenerator once, then reuse it.  This may be more optimal
+than accessing the operating-system provided entropy generator directly many times - as
+always you should test that the solution meets your performance needs:
+
+  ``[classref boost::random::random_device]`` entropy; // operating-system provided entropy generator
+  ``[classref boost::random::mt19937]`` prng;          // produces randomness out of thin air
+                                        // see pseudo-random number generators
+  ``[classref boost::random::uniform_int_distribution]<>`` six(1,6);
+                                        // distribution that maps to 1..6
+                                        // see random number distributions
+  prng.seed(entropy);                   // seed the PRNG
+  int total = 0;
+  const size_t rolls = 65536;
+  for (size_t roll = 0; roll < rolls; ++roll) {
+      total += six(prng);               // simulate rolling a die
+  }
+  double avg = static_cast<double>(total) / static_cast<double>(rolls);
 
 [endsect]
 

example/Jamfile.v2

@@ -7,6 +7,21 @@
 # accompanying file LICENSE_1_0.txt or copy at
 # http://www.boost.org/LICENSE_1_0.txt)
 
+project libs/random/example
+    : requirements
+
+      # boost.jam defines BOOST_ALL_NO_LIB for builds 
+      # which cannot be undefined?
+      <toolset>msvc:<define>BOOST_RANDOM_FORCE_AUTO_LINK
+      <toolset>gcc-mingw:<linkflags>"-lbcrypt"
+
+      # boost::random needs this setting for a warning free build:
+      <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
+
+      # link static for easier debugging - uncomment if you need to debug...
+      # <link>static
+;
+
 run die.cpp ;
 run weighted_die.cpp ;
-run password.cpp /boost//random ;
+run password.cpp ;

example/password.cpp

@@ -16,9 +16,9 @@
     password.
  */
 
-
 #include <boost/random/random_device.hpp>
 #include <boost/random/uniform_int_distribution.hpp>
+#include <iostream>
 
 int main() {
     /*<< We first define the characters that we're going

include/boost/random/detail/generator_seed_seq.hpp

@@ -1,4 +1,4 @@
-/* boost random/mersenne_twister.hpp header file
+/* boost random/detail/generator_seed_seq.hpp header file
  *
  * Copyright Jens Maurer 2000-2001
  * Copyright Steven Watanabe 2010

include/boost/random/detail/random_provider_arc4random.ipp

@@ -0,0 +1,32 @@
+//
+// Copyright (c) 2017 James E. King III
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+//   http://www.boost.org/LICENCE_1_0.txt)
+//
+// "A Replacement Call for Random"
+// https://man.openbsd.org/arc4random.3
+//
+
+#include <stdlib.h> 
+
+namespace boost {
+namespace random {
+namespace detail {
+
+class random_provider
+{
+  public:
+    //! Obtain entropy and place it into a memory location
+    //! \param[in]  buf  the location to write entropy
+    //! \param[in]  siz  the number of bytes to acquire
+    void get_random_bytes(void *buf, size_t siz)
+    {
+        arc4random_buf(buf, siz);
+    }
+};
+
+} // detail
+} // random
+} // boost

include/boost/random/detail/random_provider_bcrypt.ipp

@@ -0,0 +1,79 @@
+//
+// Copyright (c) 2017 James E. King III
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+//   http://www.boost.org/LICENCE_1_0.txt)
+//
+// BCrypt provider for entropy
+//
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/random/entropy_error.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/winapi/bcrypt.hpp>
+#include <boost/winapi/get_last_error.hpp>
+
+#if defined(BOOST_RANDOM_FORCE_AUTO_LINK) || (!defined(BOOST_ALL_NO_LIB) && !defined(BOOST_RANDOM_NO_LIB))
+#   define BOOST_LIB_NAME "bcrypt"
+#   define BOOST_AUTO_LINK_NOMANGLE
+#   include <boost/config/auto_link.hpp>
+#   undef BOOST_AUTO_LINK_NOMANGLE
+#endif
+
+namespace boost {
+namespace random {
+namespace detail {
+
+class random_provider
+{
+  public:
+    random_provider()
+      : hProv_(NULL)
+    {
+        boost::winapi::NTSTATUS_ status =
+            boost::winapi::BCryptOpenAlgorithmProvider(
+                &hProv_, 
+                boost::winapi::BCRYPT_RNG_ALGORITHM_,
+                NULL,
+                0);
+
+        if (status)
+        {
+            BOOST_THROW_EXCEPTION(entropy_error(status, "BCryptOpenAlgorithmProvider"));
+        }
+    }
+
+    ~random_provider() BOOST_NOEXCEPT
+    {
+        if (hProv_)
+        {
+            ignore_unused(boost::winapi::BCryptCloseAlgorithmProvider(hProv_, 0));
+        }
+    }
+
+    //! Obtain entropy and place it into a memory location
+    //! \param[in]  buf  the location to write entropy
+    //! \param[in]  siz  the number of bytes to acquire
+    void get_random_bytes(void *buf, size_t siz)
+    {
+        boost::winapi::NTSTATUS_ status =
+            boost::winapi::BCryptGenRandom(
+                hProv_,
+                static_cast<boost::winapi::PUCHAR_>(buf),
+                siz,
+                0);
+
+        if (status)
+        {
+            BOOST_THROW_EXCEPTION(entropy_error(status, "BCryptGenRandom"));
+        }
+    }
+
+  private:
+    boost::winapi::BCRYPT_ALG_HANDLE_ hProv_;
+};
+
+} // detail
+} // random
+} // boost