@nxtedition/rocksdb 15.2.2 → 15.2.4

package/deps/abseil-cpp/absl/random/internal/distribution_test_util_test.cc

@@ -1,193 +0,0 @@
-// Copyright 2017 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/internal/distribution_test_util.h"
-
-#include "gtest/gtest.h"
-
-namespace {
-
-TEST(TestUtil, InverseErf) {
-  const struct {
-    const double z;
-    const double value;
-  } kErfInvTable[] = {
-      {0.0000001, 8.86227e-8},
-      {0.00001, 8.86227e-6},
-      {0.5, 0.4769362762044},
-      {0.6, 0.5951160814499},
-      {0.99999, 3.1234132743},
-      {0.9999999, 3.7665625816},
-      {0.999999944, 3.8403850690566985},  // = log((1-x) * (1+x)) =~ 16.004
-      {0.999999999, 4.3200053849134452},
-  };
-
-  for (const auto& data : kErfInvTable) {
-    auto value = absl::random_internal::erfinv(data.z);
-
-    // Log using the Wolfram-alpha function name & parameters.
-    EXPECT_NEAR(value, data.value, 1e-8)
-        << " InverseErf[" << data.z << "]  (expected=" << data.value << ")  -> "
-        << value;
-  }
-}
-
-const struct {
-  const double p;
-  const double q;
-  const double x;
-  const double alpha;
-} kBetaTable[] = {
-    {0.5, 0.5, 0.01, 0.06376856085851985},
-    {0.5, 0.5, 0.1, 0.2048327646991335},
-    {0.5, 0.5, 1, 1},
-    {1, 0.5, 0, 0},
-    {1, 0.5, 0.01, 0.005012562893380045},
-    {1, 0.5, 0.1, 0.0513167019494862},
-    {1, 0.5, 0.5, 0.2928932188134525},
-    {1, 1, 0.5, 0.5},
-    {2, 2, 0.1, 0.028},
-    {2, 2, 0.2, 0.104},
-    {2, 2, 0.3, 0.216},
-    {2, 2, 0.4, 0.352},
-    {2, 2, 0.5, 0.5},
-    {2, 2, 0.6, 0.648},
-    {2, 2, 0.7, 0.784},
-    {2, 2, 0.8, 0.896},
-    {2, 2, 0.9, 0.972},
-    {5.5, 5, 0.5, 0.4361908850559777},
-    {10, 0.5, 0.9, 0.1516409096346979},
-    {10, 5, 0.5, 0.08978271484375},
-    {10, 5, 1, 1},
-    {10, 10, 0.5, 0.5},
-    {20, 5, 0.8, 0.4598773297575791},
-    {20, 10, 0.6, 0.2146816102371739},
-    {20, 10, 0.8, 0.9507364826957875},
-    {20, 20, 0.5, 0.5},
-    {20, 20, 0.6, 0.8979413687105918},
-    {30, 10, 0.7, 0.2241297491808366},
-    {30, 10, 0.8, 0.7586405487192086},
-    {40, 20, 0.7, 0.7001783247477069},
-    {1, 0.5, 0.1, 0.0513167019494862},
-    {1, 0.5, 0.2, 0.1055728090000841},
-    {1, 0.5, 0.3, 0.1633399734659245},
-    {1, 0.5, 0.4, 0.2254033307585166},
-    {1, 2, 0.2, 0.36},
-    {1, 3, 0.2, 0.488},
-    {1, 4, 0.2, 0.5904},
-    {1, 5, 0.2, 0.67232},
-    {2, 2, 0.3, 0.216},
-    {3, 2, 0.3, 0.0837},
-    {4, 2, 0.3, 0.03078},
-    {5, 2, 0.3, 0.010935},
-
-    // These values test small & large points along the range of the Beta
-    // function.
-    //
-    // When selecting test points, remember that if BetaIncomplete(x, p, q)
-    // returns the same value to within the limits of precision over a large
-    // domain of the input, x, then BetaIncompleteInv(alpha, p, q) may return an
-    // essentially arbitrary value where BetaIncomplete(x, p, q) =~ alpha.
-
-    // BetaRegularized[x, 0.00001, 0.00001],
-    // For x in {~0.001 ... ~0.999}, => ~0.5
-    {1e-5, 1e-5, 1e-5, 0.4999424388184638311},
-    {1e-5, 1e-5, (1.0 - 1e-8), 0.5000920948389232964},
-
-    // BetaRegularized[x, 0.00001, 10000].
-    // For x in {~epsilon ... 1.0}, => ~1
-    {1e-5, 1e5, 1e-6, 0.9999817708130066936},
-    {1e-5, 1e5, (1.0 - 1e-7), 1.0},
-
-    // BetaRegularized[x, 10000, 0.00001].
-    // For x in {0 .. 1-epsilon}, => ~0
-    {1e5, 1e-5, 1e-6, 0},
-    {1e5, 1e-5, (1.0 - 1e-6), 1.8229186993306369e-5},
-};
-
-TEST(BetaTest, BetaIncomplete) {
-  for (const auto& data : kBetaTable) {
-    auto value = absl::random_internal::BetaIncomplete(data.x, data.p, data.q);
-
-    // Log using the Wolfram-alpha function name & parameters.
-    EXPECT_NEAR(value, data.alpha, 1e-12)
-        << " BetaRegularized[" << data.x << ", " << data.p << ", " << data.q
-        << "]  (expected=" << data.alpha << ")  -> " << value;
-  }
-}
-
-TEST(BetaTest, BetaIncompleteInv) {
-  for (const auto& data : kBetaTable) {
-    auto value =
-        absl::random_internal::BetaIncompleteInv(data.p, data.q, data.alpha);
-
-    // Log using the Wolfram-alpha function name & parameters.
-    EXPECT_NEAR(value, data.x, 1e-6)
-        << " InverseBetaRegularized[" << data.alpha << ", " << data.p << ", "
-        << data.q << "]  (expected=" << data.x << ")  -> " << value;
-  }
-}
-
-TEST(MaxErrorTolerance, MaxErrorTolerance) {
-  std::vector<std::pair<double, double>> cases = {
-      {0.0000001, 8.86227e-8 * 1.41421356237},
-      {0.00001, 8.86227e-6 * 1.41421356237},
-      {0.5, 0.4769362762044 * 1.41421356237},
-      {0.6, 0.5951160814499 * 1.41421356237},
-      {0.99999, 3.1234132743 * 1.41421356237},
-      {0.9999999, 3.7665625816 * 1.41421356237},
-      {0.999999944, 3.8403850690566985 * 1.41421356237},
-      {0.999999999, 4.3200053849134452 * 1.41421356237}};
-  for (auto entry : cases) {
-    EXPECT_NEAR(absl::random_internal::MaxErrorTolerance(entry.first),
-                entry.second, 1e-8);
-  }
-}
-
-TEST(ZScore, WithSameMean) {
-  absl::random_internal::DistributionMoments m;
-  m.n = 100;
-  m.mean = 5;
-  m.variance = 1;
-  EXPECT_NEAR(absl::random_internal::ZScore(5, m), 0, 1e-12);
-
-  m.n = 1;
-  m.mean = 0;
-  m.variance = 1;
-  EXPECT_NEAR(absl::random_internal::ZScore(0, m), 0, 1e-12);
-
-  m.n = 10000;
-  m.mean = -5;
-  m.variance = 100;
-  EXPECT_NEAR(absl::random_internal::ZScore(-5, m), 0, 1e-12);
-}
-
-TEST(ZScore, DifferentMean) {
-  absl::random_internal::DistributionMoments m;
-  m.n = 100;
-  m.mean = 5;
-  m.variance = 1;
-  EXPECT_NEAR(absl::random_internal::ZScore(4, m), 10, 1e-12);
-
-  m.n = 1;
-  m.mean = 0;
-  m.variance = 1;
-  EXPECT_NEAR(absl::random_internal::ZScore(-1, m), 1, 1e-12);
-
-  m.n = 10000;
-  m.mean = -5;
-  m.variance = 100;
-  EXPECT_NEAR(absl::random_internal::ZScore(-4, m), -10, 1e-12);
-}
-}  // namespace

package/deps/abseil-cpp/absl/random/internal/entropy_pool.cc

@@ -1,185 +0,0 @@
-// Copyright 2017 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/internal/entropy_pool.h"
-
-#include <algorithm>
-#include <atomic>
-#include <cstdint>
-#include <cstring>
-#include <iterator>
-
-#include "absl/base/attributes.h"
-#include "absl/base/call_once.h"
-#include "absl/base/config.h"
-#include "absl/base/internal/spinlock.h"
-#include "absl/base/optimization.h"
-#include "absl/base/thread_annotations.h"
-#include "absl/random/internal/randen.h"
-#include "absl/random/internal/randen_traits.h"
-#include "absl/random/internal/seed_material.h"
-#include "absl/random/seed_gen_exception.h"
-#include "absl/types/span.h"
-
-using absl::base_internal::SpinLock;
-using absl::base_internal::SpinLockHolder;
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-namespace {
-
-// RandenPoolEntry is a thread-safe pseudorandom bit generator, implementing a
-// single generator within a RandenPool<T>. It is an internal implementation
-// detail, and does not aim to conform to [rand.req.urng].
-//
-// At least 32-byte alignment is required for the state_ array on some ARM
-// platforms.  We also want this aligned to a cacheline to eliminate false
-// sharing.
-class alignas(std::max(size_t{ABSL_CACHELINE_SIZE}, size_t{32}))
-    RandenPoolEntry {
- public:
-  static constexpr size_t kState = RandenTraits::kStateBytes / sizeof(uint32_t);
-  static constexpr size_t kCapacity =
-      RandenTraits::kCapacityBytes / sizeof(uint32_t);
-
-  void Init(absl::Span<const uint32_t> data) {
-    SpinLockHolder l(mu_);  // Always uncontested.
-    std::copy(data.begin(), data.end(), std::begin(state_));
-    next_ = kState;
-  }
-
-  // Copy bytes into out.
-  void Fill(uint8_t* out, size_t bytes) ABSL_LOCKS_EXCLUDED(mu_);
-
-  inline void MaybeRefill() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
-    if (next_ >= kState) {
-      next_ = kCapacity;
-      impl_.Generate(state_);
-    }
-  }
-
-  inline size_t available() const ABSL_SHARED_LOCKS_REQUIRED(mu_) {
-    return kState - next_;
-  }
-
- private:
-  // Randen URBG state.
-  // At least 32-byte alignment is required by ARM platform code.
-  alignas(32) uint32_t state_[kState] ABSL_GUARDED_BY(mu_);
-  SpinLock mu_;
-  const Randen impl_;
-  size_t next_ ABSL_GUARDED_BY(mu_);
-};
-
-void RandenPoolEntry::Fill(uint8_t* out, size_t bytes) {
-  SpinLockHolder l(mu_);
-  while (bytes > 0) {
-    MaybeRefill();
-    size_t remaining = available() * sizeof(state_[0]);
-    size_t to_copy = std::min(bytes, remaining);
-    std::memcpy(out, &state_[next_], to_copy);
-    out += to_copy;
-    bytes -= to_copy;
-    next_ += (to_copy + sizeof(state_[0]) - 1) / sizeof(state_[0]);
-  }
-}
-
-// Number of pooled urbg entries.
-static constexpr size_t kPoolSize = 8;
-
-// Shared pool entries.
-static absl::once_flag pool_once;
-ABSL_CACHELINE_ALIGNED static RandenPoolEntry* shared_pools[kPoolSize];
-
-// Returns an id in the range [0 ... kPoolSize), which indexes into the
-// pool of random engines.
-//
-// Each thread to access the pool is assigned a sequential ID (without reuse)
-// from the pool-id space; the id is cached in a thread_local variable.
-// This id is assigned based on the arrival-order of the thread to the
-// GetPoolID call; this has no binary, CL, or runtime stability because
-// on subsequent runs the order within the same program may be significantly
-// different. However, as other thread IDs are not assigned sequentially,
-// this is not expected to matter.
-size_t GetPoolID() {
-  static_assert(kPoolSize >= 1,
-                "At least one urbg instance is required for PoolURBG");
-
-  ABSL_CONST_INIT static std::atomic<uint64_t> sequence{0};
-
-#ifdef ABSL_HAVE_THREAD_LOCAL
-  static thread_local size_t my_pool_id = kPoolSize;
-  if (ABSL_PREDICT_FALSE(my_pool_id == kPoolSize)) {
-    my_pool_id = (sequence++ % kPoolSize);
-  }
-  return my_pool_id;
-#else
-  static pthread_key_t tid_key = [] {
-    pthread_key_t tmp_key;
-    int err = pthread_key_create(&tmp_key, nullptr);
-    if (err) {
-      ABSL_RAW_LOG(FATAL, "pthread_key_create failed with %d", err);
-    }
-    return tmp_key;
-  }();
-
-  // Store the value in the pthread_{get/set}specific. However an uninitialized
-  // value is 0, so add +1 to distinguish from the null value.
-  uintptr_t my_pool_id =
-      reinterpret_cast<uintptr_t>(pthread_getspecific(tid_key));
-  if (ABSL_PREDICT_FALSE(my_pool_id == 0)) {
-    // No allocated ID, allocate the next value, cache it, and return.
-    my_pool_id = (sequence++ % kPoolSize) + 1;
-    int err = pthread_setspecific(tid_key, reinterpret_cast<void*>(my_pool_id));
-    if (err) {
-      ABSL_RAW_LOG(FATAL, "pthread_setspecific failed with %d", err);
-    }
-  }
-  return my_pool_id - 1;
-#endif
-}
-
-// Allocate and initialize kPoolSize objects of type RandenPoolEntry.
-void InitPoolURBG() {
-  static constexpr size_t kSeedSize =
-      RandenTraits::kStateBytes / sizeof(uint32_t);
-  // Read OS entropy once, and use it to initialize each pool entry.
-  uint32_t seed_material[kPoolSize * kSeedSize];
-  if (!ReadSeedMaterialFromOSEntropy(absl::MakeSpan(seed_material))) {
-    ThrowSeedGenException();
-  }
-  for (size_t i = 0; i < kPoolSize; i++) {
-    shared_pools[i] = new RandenPoolEntry();
-    shared_pools[i]->Init(
-        absl::MakeSpan(&seed_material[i * kSeedSize], kSeedSize));
-  }
-}
-
-// Returns the pool entry for the current thread.
-RandenPoolEntry* GetPoolForCurrentThread() {
-  absl::call_once(pool_once, InitPoolURBG);
-  return shared_pools[GetPoolID()];
-}
-
-}  // namespace
-
-void GetEntropyFromRandenPool(void* dest, size_t bytes) {
-  auto* pool = GetPoolForCurrentThread();
-  pool->Fill(reinterpret_cast<uint8_t*>(dest), bytes);
-}
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
-}  // namespace absl

package/deps/abseil-cpp/absl/random/internal/entropy_pool.h

@@ -1,35 +0,0 @@
-// Copyright 2017 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_INTERNAL_ENTROPY_POOL_H_
-#define ABSL_RANDOM_INTERNAL_ENTROPY_POOL_H_
-
-#include <cstddef>
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-
-// GetEntropyFromRandenPool() is a helper function that fills a memory region
-// with random bytes from the RandenPool.  This is used by the absl::BitGen
-// implementation to fill the internal buffer.
-void GetEntropyFromRandenPool(void* dest, size_t bytes);
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_RANDOM_INTERNAL_ENTROPY_POOL_H_

package/deps/abseil-cpp/absl/random/internal/entropy_pool_test.cc

@@ -1,119 +0,0 @@
-// Copyright 2017 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/internal/entropy_pool.h"
-
-#include <bitset>
-#include <cmath>
-#include <cstddef>
-#include <cstdint>
-#include <thread>  // NOLINT
-#include <utility>
-#include <vector>
-
-#include "gtest/gtest.h"
-#include "absl/container/flat_hash_set.h"
-#include "absl/synchronization/mutex.h"
-
-namespace {
-
-using ::absl::random_internal::GetEntropyFromRandenPool;
-
-TEST(EntropyPoolTest, DistinctSequencesPerThread) {
-  using result_type = uint32_t;
-  constexpr int kNumThreads = 12;
-  constexpr size_t kValuesPerThread = 32;
-
-  // Acquire entropy from multiple threads.
-  std::vector<std::vector<result_type>> data;
-  {
-    absl::Mutex mu;
-    std::vector<std::thread> threads;
-    for (int i = 0; i < kNumThreads; i++) {
-      threads.emplace_back([&]() {
-        std::vector<result_type> v(kValuesPerThread);
-        GetEntropyFromRandenPool(v.data(), sizeof(result_type) * v.size());
-        absl::MutexLock l(mu);
-        data.push_back(std::move(v));
-      });
-    }
-    for (auto& t : threads) t.join();
-  }
-
-  EXPECT_EQ(data.size(), kNumThreads);
-
-  // There should be essentially no duplicates in the sequences.
-  size_t expected_size = 0;
-  absl::flat_hash_set<result_type> seen;
-  for (const auto& v : data) {
-    expected_size += v.size();
-    for (result_type x : v) seen.insert(x);
-  }
-  EXPECT_GE(seen.size(), expected_size - 1);
-}
-
-// This validates that sequences are independent.
-TEST(EntropyPoolTest, ValidateDistribution) {
-  using result_type = uint32_t;
-  constexpr int kNumOutputs = 16;
-  std::vector<result_type> a(kNumOutputs);
-  std::vector<result_type> b(kNumOutputs);
-
-  GetEntropyFromRandenPool(a.data(), sizeof(a[0]) * a.size());
-  GetEntropyFromRandenPool(b.data(), sizeof(b[0]) * b.size());
-
-  // Compare the two sequences, counting the number of bits that are different,
-  // then verify using a normal-approximation of the binomial distribution.
-  size_t changed_bits = 0;
-  size_t total_set = 0;
-  size_t equal_count = 0;
-  size_t zero_count = 0;
-  for (size_t i = 0; i < a.size(); ++i) {
-    std::bitset<sizeof(result_type) * 8> changed_set(a[i] ^ b[i]);
-    changed_bits += changed_set.count();
-
-    std::bitset<sizeof(result_type) * 8> a_set(a[i]);
-    std::bitset<sizeof(result_type) * 8> b_set(b[i]);
-    total_set += a_set.count() + b_set.count();
-
-    equal_count += (a[i] == b[i]) ? 1 : 0;
-
-    zero_count += (a[i] == 0) ? 1 : 0;
-    zero_count += (b[i] == 0) ? 1 : 0;
-  }
-
-  constexpr size_t kNBits = kNumOutputs * sizeof(result_type) * 8;
-
-  // This should be a binomial distribution with:
-  //    p = 0.5
-  //    n = kNBits
-  //    sigma =~ 11.3 (sqrt(n * 0.5 * 0.5))
-  // So we expect the number of changed bits to be within 5 standard deviations
-  // of the mean; this should fail less than one in 3 million times.
-  EXPECT_NEAR(changed_bits, kNBits * 0.5, 5 * std::sqrt(kNBits))
-      << "@" << changed_bits / static_cast<double>(kNBits);
-
-  // Verify that the number of set bits is also within the expected range;
-  // Note that this is summed over the two sequences, so the number of trials
-  // is twice the number of bits.
-  EXPECT_NEAR(total_set, kNBits, 5 * std::sqrt(2 * kNBits))
-      << "@" << total_set / static_cast<double>(2 * kNBits);
-
-  // A[i] == B[i] with probability ~= 16 * 1/2^32; certainly less than 1.
-  EXPECT_LE(equal_count, 1);
-
-  // Zeros values must be rare; 32 / 2^32 is certainly less than 1.
-  EXPECT_LE(zero_count, 1);
-}
-}  // namespace

package/deps/abseil-cpp/absl/random/internal/explicit_seed_seq.h

@@ -1,92 +0,0 @@
-// Copyright 2017 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_INTERNAL_EXPLICIT_SEED_SEQ_H_
-#define ABSL_RANDOM_INTERNAL_EXPLICIT_SEED_SEQ_H_
-
-#include <algorithm>
-#include <cstddef>
-#include <cstdint>
-#include <initializer_list>
-#include <iterator>
-#include <vector>
-
-#include "absl/base/config.h"
-#include "absl/base/internal/endian.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-
-// This class conforms to the C++ Standard "Seed Sequence" concept
-// [rand.req.seedseq].
-//
-// An "ExplicitSeedSeq" is meant to provide a conformant interface for
-// forwarding pre-computed seed material to the constructor of a class
-// conforming to the "Uniform Random Bit Generator" concept. This class makes no
-// attempt to mutate the state provided by its constructor, and returns it
-// directly via ExplicitSeedSeq::generate().
-//
-// If this class is asked to generate more seed material than was provided to
-// the constructor, then the remaining bytes will be filled with deterministic,
-// nonrandom data.
-class ExplicitSeedSeq {
- public:
-  using result_type = uint32_t;
-
-  ExplicitSeedSeq() : state_() {}
-
-  // Copy and move both allowed.
-  ExplicitSeedSeq(const ExplicitSeedSeq& other) = default;
-  ExplicitSeedSeq& operator=(const ExplicitSeedSeq& other) = default;
-  ExplicitSeedSeq(ExplicitSeedSeq&& other) = default;
-  ExplicitSeedSeq& operator=(ExplicitSeedSeq&& other) = default;
-
-  template <typename Iterator>
-  ExplicitSeedSeq(Iterator begin, Iterator end) {
-    for (auto it = begin; it != end; it++) {
-      state_.push_back(*it & 0xffffffff);
-    }
-  }
-
-  template <typename T>
-  ExplicitSeedSeq(std::initializer_list<T> il)
-      : ExplicitSeedSeq(il.begin(), il.end()) {}
-
-  size_t size() const { return state_.size(); }
-
-  template <typename OutIterator>
-  void param(OutIterator out) const {
-    std::copy(std::begin(state_), std::end(state_), out);
-  }
-
-  template <typename OutIterator>
-  void generate(OutIterator begin, OutIterator end) {
-    for (size_t index = 0; begin != end; begin++) {
-      *begin = state_.empty() ? 0 : state_[index++];
-      if (index >= state_.size()) {
-        index = 0;
-      }
-    }
-  }
-
- protected:
-  std::vector<uint32_t> state_;
-};
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_RANDOM_INTERNAL_EXPLICIT_SEED_SEQ_H_