path: root/absl/random/bit_gen_ref.h

//
// Copyright 2018 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// -----------------------------------------------------------------------------
// File: bit_gen_ref.h
// -----------------------------------------------------------------------------
//
// This header defines a bit generator "reference" class, for use in interfaces
// that take both Abseil (e.g. `absl::BitGen`) and standard library (e.g.
// `std::mt19937`) bit generators.

#ifndef ABSL_RANDOM_BIT_GEN_REF_H_
#define ABSL_RANDOM_BIT_GEN_REF_H_

#include "absl/base/macros.h"
#include "absl/meta/type_traits.h"
#include "absl/random/internal/distribution_caller.h"
#include "absl/random/internal/fast_uniform_bits.h"
#include "absl/random/internal/mocking_bit_gen_base.h"

namespace absl {
ABSL_NAMESPACE_BEGIN
namespace random_internal {

template <typename URBG, typename = void, typename = void, typename = void>
struct is_urbg : std::false_type {};

template <typename URBG>
struct is_urbg<
    URBG,
    absl::enable_if_t<std::is_same<
        typename URBG::result_type,
        typename std::decay<decltype((URBG::min)())>::type>::value>,
    absl::enable_if_t<std::is_same<
        typename URBG::result_type,
        typename std::decay<decltype((URBG::max)())>::type>::value>,
    absl::enable_if_t<std::is_same<
        typename URBG::result_type,
        typename std::decay<decltype(std::declval<URBG>()())>::type>::value>>
    : std::true_type {};

}  // namespace random_internal

// -----------------------------------------------------------------------------
// absl::BitGenRef
// -----------------------------------------------------------------------------
//
// `absl::BitGenRef` is a type-erasing class that provides a generator-agnostic
// non-owning "reference" interface for use in place of any specific uniform
// random bit generator (URBG). This class may be used for both Abseil
// (e.g. `absl::BitGen`, `absl::InsecureBitGen`) and Standard library (e.g
// `std::mt19937`, `std::minstd_rand`) bit generators.
//
// Like other reference classes, `absl::BitGenRef` does not own the
// underlying bit generator, and the underlying instance must outlive the
// `absl::BitGenRef`.
//
// `absl::BitGenRef` is particularly useful when used with an
// `absl::MockingBitGen` to test specific paths in functions which use random
// values.
//
// Example:
//    void TakesBitGenRef(absl::BitGenRef gen) {
//      int x = absl::Uniform<int>(gen, 0, 1000);
//    }
//
class BitGenRef {
 public:
  using result_type = uint64_t;

  BitGenRef(const absl::BitGenRef&) = default;
  BitGenRef(absl::BitGenRef&&) = default;
  BitGenRef& operator=(const absl::BitGenRef&) = default;
  BitGenRef& operator=(absl::BitGenRef&&) = default;

  template <typename URBG,
            typename absl::enable_if_t<
                (!std::is_same<URBG, BitGenRef>::value &&
                 random_internal::is_urbg<URBG>::value)>* = nullptr>
  BitGenRef(URBG& gen)  // NOLINT
      : mocked_gen_ptr_(MakeMockPointer(&gen)),
        t_erased_gen_ptr_(reinterpret_cast<uintptr_t>(&gen)),
        generate_impl_fn_(ImplFn<URBG>) {
  }

  static constexpr result_type(min)() {
    return (std::numeric_limits<result_type>::min)();
  }

  static constexpr result_type(max)() {
    return (std::numeric_limits<result_type>::max)();
  }

  result_type operator()() { return generate_impl_fn_(t_erased_gen_ptr_); }

 private:
  friend struct absl::random_internal::DistributionCaller<absl::BitGenRef>;
  using impl_fn = result_type (*)(uintptr_t);
  using mocker_base_t = absl::random_internal::MockingBitGenBase;

  // Convert an arbitrary URBG pointer into either a valid mocker_base_t
  // pointer or a nullptr.
  static inline mocker_base_t* MakeMockPointer(mocker_base_t* t) { return t; }
  static inline mocker_base_t* MakeMockPointer(void*) { return nullptr; }

  template <typename URBG>
  static result_type ImplFn(uintptr_t ptr) {
    // Ensure that the return values from operator() fill the entire
    // range promised by result_type, min() and max().
    absl::random_internal::FastUniformBits<result_type> fast_uniform_bits;
    return fast_uniform_bits(*reinterpret_cast<URBG*>(ptr));
  }

  mocker_base_t* mocked_gen_ptr_;
  uintptr_t t_erased_gen_ptr_;
  impl_fn generate_impl_fn_;
};

namespace random_internal {

template <>
struct DistributionCaller<absl::BitGenRef> {
  template <typename DistrT, typename FormatT, typename... Args>
  static typename DistrT::result_type Call(absl::BitGenRef* gen_ref,
                                           Args&&... args) {
    auto* mock_ptr = gen_ref->mocked_gen_ptr_;
    if (mock_ptr == nullptr) {
      DistrT dist(std::forward<Args>(args)...);
      return dist(*gen_ref);
    } else {
      return mock_ptr->template Call<DistrT, FormatT>(
          std::forward<Args>(args)...);
    }
  }
};

}  // namespace random_internal
ABSL_NAMESPACE_END
}  // namespace absl

#endif  // ABSL_RANDOM_BIT_GEN_REF_H_