Long live QRandomGenerator

This class provides a reasonably-secure random number generator that
does not need seeding. That is quite unlike qrand(), which requires a
seed and is low-quality (definitely not secure).

This class is also like std::random_device, but better. It provides an
operator() like std::random_device, but unlike that, it also provides a
way to fill a buffer with random data, not just one 32-bit quantity.
It's also stateless.

Finally, it also implements std::seed_seq-like generate(). It obeys the
standard requirement of the range (32-bit) but not that of the algorithm
(if you wanted that, you'd use std::seed_seq itself). Instead,
generate() fills with pure random data.

Change-Id: Icd0e0d4b27cb4e5eb892fffd14b4e3ba9ea04da8
Reviewed-by: Lars Knoll <lars.knoll@qt.io>

1 files changed, 154 insertions, 0 deletions

diff --git a/src/corelib/global/qrandom.h b/src/corelib/global/qrandom.h
new file mode 100644
index 0000000000..3bede87fa6
--- /dev/null
+++ b/src/corelib/global/qrandom.h
@@ -0,0 +1,154 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 Intel Corporation.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QRANDOM_H
+#define QRANDOM_H
+
+#include <QtCore/qglobal.h>
+#include <algorithm>    // for std::generate
+
+QT_BEGIN_NAMESPACE
+
+class QRandomGenerator
+{
+    // restrict the template parameters to unsigned integers 32 bits wide or larger
+    template <typename UInt> using IfValidUInt =
+        typename std::enable_if<std::is_unsigned<UInt>::value && sizeof(UInt) >= sizeof(uint), bool>::type;
+public:
+    QRandomGenerator() = default;
+
+    static Q_CORE_EXPORT quint32 get32();
+    static Q_CORE_EXPORT quint64 get64();
+    static qreal getReal()
+    {
+        const int digits = std::numeric_limits<qreal>::digits;
+        if (digits < std::numeric_limits<quint32>::digits) {
+            // use get32()
+            return qreal(get32()) / ((max)() + qreal(1.0));
+        } else {
+            // use get64()
+            // we won't have enough bits for a __float128 though
+            return qreal(get64()) / ((std::numeric_limits<quint64>::max)() + qreal(1.0));
+        }
+    }
+
+    static qreal bounded(qreal sup)
+    {
+        return getReal() * sup;
+    }
+
+    static quint32 bounded(quint32 sup)
+    {
+        quint64 value = get32();
+        value *= sup;
+        value /= (max)() + quint64(1);
+        return quint32(value);
+    }
+
+    static int bounded(int sup)
+    {
+        return int(bounded(quint32(sup)));
+    }
+
+    static quint32 bounded(quint32 min, quint32 sup)
+    {
+        return bounded(sup - min) + min;
+    }
+
+    static int bounded(int min, int sup)
+    {
+        return bounded(sup - min) + min;
+    }
+
+    template <typename UInt, IfValidUInt<UInt> = true>
+    static void fillRange(UInt *buffer, qssize_t count)
+    {
+        fillRange_helper(buffer, buffer + count);
+    }
+
+    template <typename UInt, size_t N, IfValidUInt<UInt> = true>
+    static void fillRange(UInt (&buffer)[N])
+    {
+        fillRange_helper(buffer, buffer + N);
+    }
+
+    // API like std::seed_seq
+    template <typename ForwardIterator>
+    void generate(ForwardIterator begin, ForwardIterator end)
+    {
+        std::generate(begin, end, &QRandomGenerator::get32);
+    }
+
+    void generate(quint32 *begin, quint32 *end)
+    {
+        fillRange_helper(begin, end);
+    }
+
+    // API like std::random_device
+    typedef quint32 result_type;
+    result_type operator()() { return get32(); }
+    double entropy() const Q_DECL_NOTHROW { return 0.0; }
+    static Q_DECL_CONSTEXPR result_type min() { return (std::numeric_limits<result_type>::min)(); }
+    static Q_DECL_CONSTEXPR result_type max() { return (std::numeric_limits<result_type>::max)(); }
+
+private:
+    Q_DISABLE_COPY(QRandomGenerator)
+    static Q_CORE_EXPORT void fillRange_helper(void *buffer, void *bufferEnd);
+};
+
+class QRandomGenerator64
+{
+public:
+    QRandomGenerator64() = default;
+
+    // API like std::random_device
+    typedef quint64 result_type;
+    result_type operator()() { return QRandomGenerator::get64(); }
+    double entropy() const Q_DECL_NOTHROW { return 0.0; }
+    static Q_DECL_CONSTEXPR result_type min() { return (std::numeric_limits<result_type>::min)(); }
+    static Q_DECL_CONSTEXPR result_type max() { return (std::numeric_limits<result_type>::max)(); }
+
+private:
+    Q_DISABLE_COPY(QRandomGenerator64)
+};
+
+
+QT_END_NAMESPACE
+
+#endif // QRANDOM_H