maurice/snix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Export of internal Abseil changes

Browse source 
--
990253454819ce26ff1dda9ab4bbc145b61d01e4 by Xiaoyi Zhang <zhangxy@google.com>:

Import github PR https://github.com/abseil/abseil-cpp/pull/645

PiperOrigin-RevId: 303119797

--
5ac845cb7929b7d1eaf59a309afd811db5001175 by Abseil Team <absl-team@google.com>:

Fix internal exception spec compatibility error

PiperOrigin-RevId: 303104081

--
3290595dd866eecab3c7044e2e3ca0adb74f1bf5 by Gennadiy Rozental <rogeeff@google.com>:

Use FlagValue<T> to represent the value of a flag. Place it directly after
FlagImpl and use a computed offset refer to it.

The offset is computed based on the assumption that the `value_` data member
is placed directly after the impl_ data member in Flag<T>.

This change will allow us to migrate to `T`-specific storage in the generic case.

This change decreases the overhead for int flags by 32 bytes.

PiperOrigin-RevId: 303038099

--
f2b37722cd7a6d3a60ef9713f0d2bbff56f3ddbf by Derek Mauro <dmauro@google.com>:

Minor correctness fix for an ABSL_HAVE_BUILTIN conditional

PiperOrigin-RevId: 302980666

--
39c079a6141ae1c5728af8bf33a39c8aff9deb9f by Abseil Team <absl-team@google.com>:

Use ABSL_HARDENING_ASSERT in b-tree and SwissTable iterators.

PiperOrigin-RevId: 302970075

--
9668a044e080c789df32bcaa1ffb5100831cd9fa by Benjamin Barenblat <bbaren@google.com>:

Correct `add_subdirectory` line in CMake googletest support

Commit bcefbdcdf6 added support for building with CMake against a local googletest checkout, but I missed a line when constructing the diff. Change the `add_subdirectory` line to reference the correct directories.

PiperOrigin-RevId: 302947488

--
0a3c10fabf80a43ca69ab8b1570030e55f2be741 by Andy Soffer <asoffer@google.com>:

Remove unused distribution format traits.

PiperOrigin-RevId: 302896176

--
0478f2f6270e5ed64c0e28ec09556ca90b2d46a9 by Samuel Benzaquen <sbenza@google.com>:

Fix for CWG:2310.

PiperOrigin-RevId: 302734089

--
3cb978dda5cae5905affdc0914dcc2d27671ed11 by Samuel Benzaquen <sbenza@google.com>:

Fix the Allocate/Deallocate functions to use the same underlying allocator type.

PiperOrigin-RevId: 302721804

--
ae38d3984fb68b4e3ddc165fa8d5c24d5936be52 by Matthew Brown <matthewbr@google.com>:

Internal Change

PiperOrigin-RevId: 302717314

--
7357cf7abd03cc60b6e82b5f28a8e34935c3b4dc by Andy Getzendanner <durandal@google.com>:

Fix typo: s/ABSL_HARDENED_ASSERT/ABSL_HARDENING_ASSERT/

PiperOrigin-RevId: 302532164
GitOrigin-RevId: 990253454819ce26ff1dda9ab4bbc145b61d01e4
Change-Id: Ie595a221c16e1e7e1255ad42e029b646c5f3e11d
This commit is contained in:
Abseil Team 2020-03-26 08:48:01 -07:00 • committed by Xiaoyi Zhang
parent 132d791b40
commit 79e0dc1151
29 changed files with 387 additions and 607 deletions
Download patch file Download diff file Expand all files Collapse all files

5
absl/random/BUILD.bazel
View file

@ -53,7 +53,6 @@ cc_library(
"bernoulli_distribution.h",
"beta_distribution.h",
"discrete_distribution.h",
"distribution_format_traits.h",
"distributions.h",
"exponential_distribution.h",
"gaussian_distribution.h",
@ -141,16 +140,12 @@ cc_library(
cc_library(
name = "mocking_bit_gen",
testonly = 1,
srcs = [
"mocking_bit_gen.cc",
],
hdrs = [
"mocking_bit_gen.h",
],
linkopts = ABSL_DEFAULT_LINKOPTS,
deps = [
":distributions",
"//absl/base:raw_logging_internal",
"//absl/container:flat_hash_map",
"//absl/meta:type_traits",
"//absl/random/internal:distribution_caller",

3
absl/random/CMakeLists.txt
View file

@ -102,8 +102,6 @@ absl_cc_library(
HDRS
"mock_distributions.h"
"mocking_bit_gen.h"
SRCS
"mocking_bit_gen.cc"
COPTS
${ABSL_DEFAULT_COPTS}
LINKOPTS
@ -168,7 +166,6 @@ absl_cc_library(
"bernoulli_distribution.h"
"beta_distribution.h"
"discrete_distribution.h"
"distribution_format_traits.h"
"distributions.h"
"exponential_distribution.h"
"gaussian_distribution.h"

5
absl/random/bit_gen_ref.h
View file

@ -132,7 +132,7 @@ namespace random_internal {
template <>
struct DistributionCaller<absl::BitGenRef> {
template <typename DistrT, typename FormatT, typename... Args>
template <typename DistrT, typename... Args>
static typename DistrT::result_type Call(absl::BitGenRef* gen_ref,
Args&&... args) {
auto* mock_ptr = gen_ref->mocked_gen_ptr_;
@ -140,8 +140,7 @@ struct DistributionCaller<absl::BitGenRef> {
DistrT dist(std::forward<Args>(args)...);
return dist(*gen_ref);
} else {
return mock_ptr->template Call<DistrT, FormatT>(
std::forward<Args>(args)...);
return mock_ptr->template Call<DistrT>(std::forward<Args>(args)...);
}
}
};

278
absl/random/distribution_format_traits.h
View file

@ -1,278 +0,0 @@
//
// 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.
//
#ifndef ABSL_RANDOM_DISTRIBUTION_FORMAT_TRAITS_H_
#define ABSL_RANDOM_DISTRIBUTION_FORMAT_TRAITS_H_
#include <string>
#include <tuple>
#include <typeinfo>
#include "absl/meta/type_traits.h"
#include "absl/random/bernoulli_distribution.h"
#include "absl/random/beta_distribution.h"
#include "absl/random/exponential_distribution.h"
#include "absl/random/gaussian_distribution.h"
#include "absl/random/log_uniform_int_distribution.h"
#include "absl/random/poisson_distribution.h"
#include "absl/random/uniform_int_distribution.h"
#include "absl/random/uniform_real_distribution.h"
#include "absl/random/zipf_distribution.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_join.h"
#include "absl/strings/string_view.h"
#include "absl/types/span.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
struct IntervalClosedClosedTag;
struct IntervalClosedOpenTag;
struct IntervalOpenClosedTag;
struct IntervalOpenOpenTag;
namespace random_internal {
// ScalarTypeName defines a preferred hierarchy of preferred type names for
// scalars, and is evaluated at compile time for the specific type
// specialization.
template <typename T>
constexpr const char* ScalarTypeName() {
static_assert(std::is_integral<T>() || std::is_floating_point<T>(), "");
// clang-format off
return
std::is_same<T, float>::value ? "float" :
std::is_same<T, double>::value ? "double" :
std::is_same<T, long double>::value ? "long double" :
std::is_same<T, bool>::value ? "bool" :
std::is_signed<T>::value && sizeof(T) == 1 ? "int8_t" :
std::is_signed<T>::value && sizeof(T) == 2 ? "int16_t" :
std::is_signed<T>::value && sizeof(T) == 4 ? "int32_t" :
std::is_signed<T>::value && sizeof(T) == 8 ? "int64_t" :
std::is_unsigned<T>::value && sizeof(T) == 1 ? "uint8_t" :
std::is_unsigned<T>::value && sizeof(T) == 2 ? "uint16_t" :
std::is_unsigned<T>::value && sizeof(T) == 4 ? "uint32_t" :
std::is_unsigned<T>::value && sizeof(T) == 8 ? "uint64_t" :
"undefined";
// clang-format on
// NOTE: It would be nice to use typeid(T).name(), but that's an
// implementation-defined attribute which does not necessarily
// correspond to a name. We could potentially demangle it
// using, e.g. abi::__cxa_demangle.
}
// Distribution traits used by DistributionCaller and internal implementation
// details of the mocking framework.
/*
struct DistributionFormatTraits {
// Returns the parameterized name of the distribution function.
static constexpr const char* FunctionName()
// Format DistrT parameters.
static std::string FormatArgs(DistrT& dist);
// Format DistrT::result_type results.
static std::string FormatResults(DistrT& dist);
};
*/
template <typename DistrT>
struct DistributionFormatTraits;
template <typename R>
struct DistributionFormatTraits<absl::uniform_int_distribution<R>> {
using distribution_t = absl::uniform_int_distribution<R>;
using result_t = typename distribution_t::result_type;
static constexpr const char* Name() { return "Uniform"; }
static std::string FunctionName() {
return absl::StrCat(Name(), "<", ScalarTypeName<R>(), ">");
}
static std::string FormatArgs(const distribution_t& d) {
return absl::StrCat("absl::IntervalClosedClosed, ", (d.min)(), ", ",
(d.max)());
}
static std::string FormatResults(absl::Span<const result_t> results) {
return absl::StrJoin(results, ", ");
}
};
template <typename R>
struct DistributionFormatTraits<absl::uniform_real_distribution<R>> {
using distribution_t = absl::uniform_real_distribution<R>;
using result_t = typename distribution_t::result_type;
static constexpr const char* Name() { return "Uniform"; }
static std::string FunctionName() {
return absl::StrCat(Name(), "<", ScalarTypeName<R>(), ">");
}
static std::string FormatArgs(const distribution_t& d) {
return absl::StrCat((d.min)(), ", ", (d.max)());
}
static std::string FormatResults(absl::Span<const result_t> results) {
return absl::StrJoin(results, ", ");
}
};
template <typename R>
struct DistributionFormatTraits<absl::exponential_distribution<R>> {
using distribution_t = absl::exponential_distribution<R>;
using result_t = typename distribution_t::result_type;
static constexpr const char* Name() { return "Exponential"; }
static std::string FunctionName() {
return absl::StrCat(Name(), "<", ScalarTypeName<R>(), ">");
}
static std::string FormatArgs(const distribution_t& d) {
return absl::StrCat(d.lambda());
}
static std::string FormatResults(absl::Span<const result_t> results) {
return absl::StrJoin(results, ", ");
}
};
template <typename R>
struct DistributionFormatTraits<absl::poisson_distribution<R>> {
using distribution_t = absl::poisson_distribution<R>;
using result_t = typename distribution_t::result_type;
static constexpr const char* Name() { return "Poisson"; }
static std::string FunctionName() {
return absl::StrCat(Name(), "<", ScalarTypeName<R>(), ">");
}
static std::string FormatArgs(const distribution_t& d) {
return absl::StrCat(d.mean());
}
static std::string FormatResults(absl::Span<const result_t> results) {
return absl::StrJoin(results, ", ");
}
};
template <>
struct DistributionFormatTraits<absl::bernoulli_distribution> {
using distribution_t = absl::bernoulli_distribution;
using result_t = typename distribution_t::result_type;
static constexpr const char* Name() { return "Bernoulli"; }
static constexpr const char* FunctionName() { return Name(); }
static std::string FormatArgs(const distribution_t& d) {
return absl::StrCat(d.p());
}
static std::string FormatResults(absl::Span<const result_t> results) {
return absl::StrJoin(results, ", ");
}
};
template <typename R>
struct DistributionFormatTraits<absl::beta_distribution<R>> {
using distribution_t = absl::beta_distribution<R>;
using result_t = typename distribution_t::result_type;
static constexpr const char* Name() { return "Beta"; }
static std::string FunctionName() {
return absl::StrCat(Name(), "<", ScalarTypeName<R>(), ">");
}
static std::string FormatArgs(const distribution_t& d) {
return absl::StrCat(d.alpha(), ", ", d.beta());
}
static std::string FormatResults(absl::Span<const result_t> results) {
return absl::StrJoin(results, ", ");
}
};
template <typename R>
struct DistributionFormatTraits<absl::zipf_distribution<R>> {
using distribution_t = absl::zipf_distribution<R>;
using result_t = typename distribution_t::result_type;
static constexpr const char* Name() { return "Zipf"; }
static std::string FunctionName() {
return absl::StrCat(Name(), "<", ScalarTypeName<R>(), ">");
}
static std::string FormatArgs(const distribution_t& d) {
return absl::StrCat(d.k(), ", ", d.v(), ", ", d.q());
}
static std::string FormatResults(absl::Span<const result_t> results) {
return absl::StrJoin(results, ", ");
}
};
template <typename R>
struct DistributionFormatTraits<absl::gaussian_distribution<R>> {
using distribution_t = absl::gaussian_distribution<R>;
using result_t = typename distribution_t::result_type;
static constexpr const char* Name() { return "Gaussian"; }
static std::string FunctionName() {
return absl::StrCat(Name(), "<", ScalarTypeName<R>(), ">");
}
static std::string FormatArgs(const distribution_t& d) {
return absl::StrJoin(std::make_tuple(d.mean(), d.stddev()), ", ");
}
static std::string FormatResults(absl::Span<const result_t> results) {
return absl::StrJoin(results, ", ");
}
};
template <typename R>
struct DistributionFormatTraits<absl::log_uniform_int_distribution<R>> {
using distribution_t = absl::log_uniform_int_distribution<R>;
using result_t = typename distribution_t::result_type;
static constexpr const char* Name() { return "LogUniform"; }
static std::string FunctionName() {
return absl::StrCat(Name(), "<", ScalarTypeName<R>(), ">");
}
static std::string FormatArgs(const distribution_t& d) {
return absl::StrJoin(std::make_tuple((d.min)(), (d.max)(), d.base()), ", ");
}
static std::string FormatResults(absl::Span<const result_t> results) {
return absl::StrJoin(results, ", ");
}
};
template <typename NumType>
struct UniformDistributionWrapper;
template <typename NumType>
struct DistributionFormatTraits<UniformDistributionWrapper<NumType>> {
using distribution_t = UniformDistributionWrapper<NumType>;
using result_t = NumType;
static constexpr const char* Name() { return "Uniform"; }
static std::string FunctionName() {
return absl::StrCat(Name(), "<", ScalarTypeName<NumType>(), ">");
}
static std::string FormatArgs(const distribution_t& d) {
return absl::StrCat((d.min)(), ", ", (d.max)());
}
static std::string FormatResults(absl::Span<const result_t> results) {
return absl::StrJoin(results, ", ");
}
};
} // namespace random_internal
ABSL_NAMESPACE_END
} // namespace absl
#endif // ABSL_RANDOM_DISTRIBUTION_FORMAT_TRAITS_H_

37
absl/random/distributions.h
View file

@ -55,7 +55,6 @@
#include "absl/base/internal/inline_variable.h"
#include "absl/random/bernoulli_distribution.h"
#include "absl/random/beta_distribution.h"
#include "absl/random/distribution_format_traits.h"
#include "absl/random/exponential_distribution.h"
#include "absl/random/gaussian_distribution.h"
#include "absl/random/internal/distributions.h" // IWYU pragma: export
@ -126,14 +125,13 @@ Uniform(TagType tag,
R lo, R hi) {
using gen_t = absl::decay_t<URBG>;
using distribution_t = random_internal::UniformDistributionWrapper<R>;
using format_t = random_internal::DistributionFormatTraits<distribution_t>;
auto a = random_internal::uniform_lower_bound(tag, lo, hi);
auto b = random_internal::uniform_upper_bound(tag, lo, hi);
if (a > b) return a;
return random_internal::DistributionCaller<gen_t>::template Call<
distribution_t, format_t>(&urbg, tag, lo, hi);
distribution_t>(&urbg, tag, lo, hi);
}
// absl::Uniform<T>(bitgen, lo, hi)
@ -146,7 +144,6 @@ Uniform(URBG&& urbg, // NOLINT(runtime/references)
R lo, R hi) {
using gen_t = absl::decay_t<URBG>;
using distribution_t = random_internal::UniformDistributionWrapper<R>;
using format_t = random_internal::DistributionFormatTraits<distribution_t>;
constexpr auto tag = absl::IntervalClosedOpen;
auto a = random_internal::uniform_lower_bound(tag, lo, hi);
@ -154,7 +151,7 @@ Uniform(URBG&& urbg, // NOLINT(runtime/references)
if (a > b) return a;
return random_internal::DistributionCaller<gen_t>::template Call<
distribution_t, format_t>(&urbg, lo, hi);
distribution_t>(&urbg, lo, hi);
}
// absl::Uniform(tag, bitgen, lo, hi)
@ -172,14 +169,13 @@ Uniform(TagType tag,
using gen_t = absl::decay_t<URBG>;
using return_t = typename random_internal::uniform_inferred_return_t<A, B>;
using distribution_t = random_internal::UniformDistributionWrapper<return_t>;
using format_t = random_internal::DistributionFormatTraits<distribution_t>;
auto a = random_internal::uniform_lower_bound<return_t>(tag, lo, hi);
auto b = random_internal::uniform_upper_bound<return_t>(tag, lo, hi);
if (a > b) return a;
return random_internal::DistributionCaller<gen_t>::template Call<
distribution_t, format_t>(&urbg, tag, static_cast<return_t>(lo),
distribution_t>(&urbg, tag, static_cast<return_t>(lo),
static_cast<return_t>(hi));
}
@ -196,7 +192,6 @@ Uniform(URBG&& urbg, // NOLINT(runtime/references)
using gen_t = absl::decay_t<URBG>;
using return_t = typename random_internal::uniform_inferred_return_t<A, B>;
using distribution_t = random_internal::UniformDistributionWrapper<return_t>;
using format_t = random_internal::DistributionFormatTraits<distribution_t>;
constexpr auto tag = absl::IntervalClosedOpen;
auto a = random_internal::uniform_lower_bound<return_t>(tag, lo, hi);
@ -204,7 +199,7 @@ Uniform(URBG&& urbg, // NOLINT(runtime/references)
if (a > b) return a;
return random_internal::DistributionCaller<gen_t>::template Call<
distribution_t, format_t>(&urbg, static_cast<return_t>(lo),
distribution_t>(&urbg, static_cast<return_t>(lo),
static_cast<return_t>(hi));
}
@ -217,10 +212,9 @@ typename absl::enable_if_t<!std::is_signed<R>::value, R> //
Uniform(URBG&& urbg) { // NOLINT(runtime/references)
using gen_t = absl::decay_t<URBG>;
using distribution_t = random_internal::UniformDistributionWrapper<R>;
using format_t = random_internal::DistributionFormatTraits<distribution_t>;
return random_internal::DistributionCaller<gen_t>::template Call<
distribution_t, format_t>(&urbg);
distribution_t>(&urbg);
}
// -----------------------------------------------------------------------------
@ -248,10 +242,9 @@ bool Bernoulli(URBG&& urbg, // NOLINT(runtime/references)
double p) {
using gen_t = absl::decay_t<URBG>;
using distribution_t = absl::bernoulli_distribution;
using format_t = random_internal::DistributionFormatTraits<distribution_t>;
return random_internal::DistributionCaller<gen_t>::template Call<
distribution_t, format_t>(&urbg, p);
distribution_t>(&urbg, p);
}
// -----------------------------------------------------------------------------
@ -281,10 +274,9 @@ RealType Beta(URBG&& urbg, // NOLINT(runtime/references)
using gen_t = absl::decay_t<URBG>;
using distribution_t = typename absl::beta_distribution<RealType>;
using format_t = random_internal::DistributionFormatTraits<distribution_t>;
return random_internal::DistributionCaller<gen_t>::template Call<
distribution_t, format_t>(&urbg, alpha, beta);
distribution_t>(&urbg, alpha, beta);
}
// -----------------------------------------------------------------------------
@ -314,10 +306,9 @@ RealType Exponential(URBG&& urbg, // NOLINT(runtime/references)
using gen_t = absl::decay_t<URBG>;
using distribution_t = typename absl::exponential_distribution<RealType>;
using format_t = random_internal::DistributionFormatTraits<distribution_t>;
return random_internal::DistributionCaller<gen_t>::template Call<
distribution_t, format_t>(&urbg, lambda);
distribution_t>(&urbg, lambda);
}
// -----------------------------------------------------------------------------
@ -346,10 +337,9 @@ RealType Gaussian(URBG&& urbg, // NOLINT(runtime/references)
using gen_t = absl::decay_t<URBG>;
using distribution_t = typename absl::gaussian_distribution<RealType>;
using format_t = random_internal::DistributionFormatTraits<distribution_t>;
return random_internal::DistributionCaller<gen_t>::template Call<
distribution_t, format_t>(&urbg, mean, stddev);
distribution_t>(&urbg, mean, stddev);
}
// -----------------------------------------------------------------------------
@ -389,10 +379,9 @@ IntType LogUniform(URBG&& urbg, // NOLINT(runtime/references)
using gen_t = absl::decay_t<URBG>;
using distribution_t = typename absl::log_uniform_int_distribution<IntType>;
using format_t = random_internal::DistributionFormatTraits<distribution_t>;
return random_internal::DistributionCaller<gen_t>::template Call<
distribution_t, format_t>(&urbg, lo, hi, base);
distribution_t>(&urbg, lo, hi, base);
}
// -----------------------------------------------------------------------------
@ -420,10 +409,9 @@ IntType Poisson(URBG&& urbg, // NOLINT(runtime/references)
using gen_t = absl::decay_t<URBG>;
using distribution_t = typename absl::poisson_distribution<IntType>;
using format_t = random_internal::DistributionFormatTraits<distribution_t>;
return random_internal::DistributionCaller<gen_t>::template Call<
distribution_t, format_t>(&urbg, mean);
distribution_t>(&urbg, mean);
}
// -----------------------------------------------------------------------------
@ -453,10 +441,9 @@ IntType Zipf(URBG&& urbg, // NOLINT(runtime/references)
using gen_t = absl::decay_t<URBG>;
using distribution_t = typename absl::zipf_distribution<IntType>;
using format_t = random_internal::DistributionFormatTraits<distribution_t>;
return random_internal::DistributionCaller<gen_t>::template Call<
distribution_t, format_t>(&urbg, hi, q, v);
distribution_t>(&urbg, hi, q, v);
}
ABSL_NAMESPACE_END

15
absl/random/internal/distribution_caller.h
View file

@ -33,20 +33,7 @@ struct DistributionCaller {
// Call the provided distribution type. The parameters are expected
// to be explicitly specified.
// DistrT is the distribution type.
// FormatT is the formatter type:
//
// struct FormatT {
// using result_type = distribution_t::result_type;
// static std::string FormatCall(
// const distribution_t& distr,
// absl::Span<const result_type>);
//
// static std::string FormatExpectation(
// absl::string_view match_args,
// absl::Span<const result_t> results);
// }
//
template <typename DistrT, typename FormatT, typename... Args>
template <typename DistrT, typename... Args>
static typename DistrT::result_type Call(URBG* urbg, Args&&... args) {
DistrT dist(std::forward<Args>(args)...);
return dist(*urbg);

39
absl/random/internal/mocking_bit_gen_base.h
View file

@ -16,8 +16,6 @@
#ifndef ABSL_RANDOM_INTERNAL_MOCKING_BIT_GEN_BASE_H_
#define ABSL_RANDOM_INTERNAL_MOCKING_BIT_GEN_BASE_H_
#include <atomic>
#include <deque>
#include <string>
#include <typeinfo>
@ -28,27 +26,6 @@ namespace absl {
ABSL_NAMESPACE_BEGIN
namespace random_internal {
// MockingBitGenExpectationFormatter is invoked to format unsatisfied mocks
// and remaining results into a description string.
template <typename DistrT, typename FormatT>
struct MockingBitGenExpectationFormatter {
std::string operator()(absl::string_view args) {
return absl::StrCat(FormatT::FunctionName(), "(", args, ")");
}
};
// MockingBitGenCallFormatter is invoked to format each distribution call
// into a description string for the mock log.
template <typename DistrT, typename FormatT>
struct MockingBitGenCallFormatter {
std::string operator()(const DistrT& dist,
const typename DistrT::result_type& result) {
return absl::StrCat(
FormatT::FunctionName(), "(", FormatT::FormatArgs(dist), ") => {",
FormatT::FormatResults(absl::MakeSpan(&result, 1)), "}");
}
};
class MockingBitGenBase {
template <typename>
friend struct DistributionCaller;
@ -61,14 +38,9 @@ class MockingBitGenBase {
static constexpr result_type(max)() { return (generator_type::max)(); }
result_type operator()() { return gen_(); }
MockingBitGenBase() : gen_(), observed_call_log_() {}
virtual ~MockingBitGenBase() = default;
protected:
const std::deque<std::string>& observed_call_log() {
return observed_call_log_;
}
// CallImpl is the type-erased virtual dispatch.
// The type of dist is always distribution<T>,
// The type of result is always distribution<T>::result_type.
@ -81,10 +53,9 @@ class MockingBitGenBase {
}
// Call the generating distribution function.
// Invoked by DistributionCaller<>::Call<DistT, FormatT>.
// Invoked by DistributionCaller<>::Call<DistT>.
// DistT is the distribution type.
// FormatT is the distribution formatter traits type.
template <typename DistrT, typename FormatT, typename... Args>
template <typename DistrT, typename... Args>
typename DistrT::result_type Call(Args&&... args) {
using distr_result_type = typename DistrT::result_type;
using ArgTupleT = std::tuple<absl::decay_t<Args>...>;
@ -100,17 +71,11 @@ class MockingBitGenBase {
result = dist(gen_);
}
// TODO(asoffer): Forwarding the args through means we no longer need to
// extract them from the from the distribution in formatter traits. We can
// just StrJoin them.
observed_call_log_.push_back(
MockingBitGenCallFormatter<DistrT, FormatT>{}(dist, result));
return result;
}
private:
generator_type gen_;
std::deque<std::string> observed_call_log_;
}; // namespace random_internal
} // namespace random_internal

30
absl/random/mocking_bit_gen.cc
View file

@ -1,30 +0,0 @@
//
// 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.
//
#include "absl/random/mocking_bit_gen.h"
#include <string>
namespace absl {
ABSL_NAMESPACE_BEGIN
MockingBitGen::~MockingBitGen() {
for (const auto& del : deleters_) {
del();
}
}
ABSL_NAMESPACE_END
} // namespace absl

8
absl/random/mocking_bit_gen.h
View file

@ -100,7 +100,9 @@ class MockingBitGen : public absl::random_internal::MockingBitGenBase {
public:
MockingBitGen() {}
~MockingBitGen() override;
~MockingBitGen() override {
for (const auto& del : deleters_) del();
}
private:
template <typename DistrT, typename... Args>
@ -182,10 +184,10 @@ namespace random_internal {
template <>
struct DistributionCaller<absl::MockingBitGen> {
template <typename DistrT, typename FormatT, typename... Args>
template <typename DistrT, typename... Args>
static typename DistrT::result_type Call(absl::MockingBitGen* gen,
Args&&... args) {
return gen->template Call<DistrT, FormatT>(std::forward<Args>(args)...);
return gen->template Call<DistrT>(std::forward<Args>(args)...);
}
};