re2 1.22.2 → 1.23.0

package/vendor/abseil-cpp/absl/base/invoke_test.cc

@@ -1,331 +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/base/internal/invoke.h"
-
-#include <functional>
-#include <memory>
-#include <string>
-#include <utility>
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/memory/memory.h"
-#include "absl/strings/str_cat.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace base_internal {
-namespace {
-
-int Function(int a, int b) { return a - b; }
-
-void VoidFunction(int& a, int& b) {
-  a += b;
-  b = a - b;
-  a -= b;
-}
-
-int ZeroArgFunction() { return -1937; }
-
-int Sink(std::unique_ptr<int> p) {
-  return *p;
-}
-
-std::unique_ptr<int> Factory(int n) {
-  return make_unique<int>(n);
-}
-
-void NoOp() {}
-
-struct ConstFunctor {
-  int operator()(int a, int b) const { return a - b; }
-};
-
-struct MutableFunctor {
-  int operator()(int a, int b) { return a - b; }
-};
-
-struct EphemeralFunctor {
-  int operator()(int a, int b) && { return a - b; }
-};
-
-struct OverloadedFunctor {
-  template <typename... Args>
-  std::string operator()(const Args&... args) & {
-    return StrCat("&", args...);
-  }
-  template <typename... Args>
-  std::string operator()(const Args&... args) const& {
-    return StrCat("const&", args...);
-  }
-  template <typename... Args>
-  std::string operator()(const Args&... args) && {
-    return StrCat("&&", args...);
-  }
-};
-
-struct Class {
-  int Method(int a, int b) { return a - b; }
-  int ConstMethod(int a, int b) const { return a - b; }
-  int RefMethod(int a, int b) & { return a - b; }
-  int RefRefMethod(int a, int b) && { return a - b; }
-  int NoExceptMethod(int a, int b) noexcept { return a - b; }
-  int VolatileMethod(int a, int b) volatile { return a - b; }
-
-  int member;
-};
-
-struct FlipFlop {
-  int ConstMethod() const { return member; }
-  FlipFlop operator*() const { return {-member}; }
-
-  int member;
-};
-
-// CallMaybeWithArg(f) resolves either to invoke(f) or invoke(f, 42), depending
-// on which one is valid.
-template <typename F>
-decltype(base_internal::invoke(std::declval<const F&>())) CallMaybeWithArg(
-    const F& f) {
-  return base_internal::invoke(f);
-}
-
-template <typename F>
-decltype(base_internal::invoke(std::declval<const F&>(), 42)) CallMaybeWithArg(
-    const F& f) {
-  return base_internal::invoke(f, 42);
-}
-
-TEST(InvokeTest, Function) {
-  EXPECT_EQ(1, base_internal::invoke(Function, 3, 2));
-  EXPECT_EQ(1, base_internal::invoke(&Function, 3, 2));
-}
-
-TEST(InvokeTest, NonCopyableArgument) {
-  EXPECT_EQ(42, base_internal::invoke(Sink, make_unique<int>(42)));
-}
-
-TEST(InvokeTest, NonCopyableResult) {
-  EXPECT_THAT(base_internal::invoke(Factory, 42), ::testing::Pointee(42));
-}
-
-TEST(InvokeTest, VoidResult) { base_internal::invoke(NoOp); }
-
-TEST(InvokeTest, ConstFunctor) {
-  EXPECT_EQ(1, base_internal::invoke(ConstFunctor(), 3, 2));
-}
-
-TEST(InvokeTest, MutableFunctor) {
-  MutableFunctor f;
-  EXPECT_EQ(1, base_internal::invoke(f, 3, 2));
-  EXPECT_EQ(1, base_internal::invoke(MutableFunctor(), 3, 2));
-}
-
-TEST(InvokeTest, EphemeralFunctor) {
-  EphemeralFunctor f;
-  EXPECT_EQ(1, base_internal::invoke(std::move(f), 3, 2));
-  EXPECT_EQ(1, base_internal::invoke(EphemeralFunctor(), 3, 2));
-}
-
-TEST(InvokeTest, OverloadedFunctor) {
-  OverloadedFunctor f;
-  const OverloadedFunctor& cf = f;
-
-  EXPECT_EQ("&", base_internal::invoke(f));
-  EXPECT_EQ("& 42", base_internal::invoke(f, " 42"));
-
-  EXPECT_EQ("const&", base_internal::invoke(cf));
-  EXPECT_EQ("const& 42", base_internal::invoke(cf, " 42"));
-
-  EXPECT_EQ("&&", base_internal::invoke(std::move(f)));
-
-  OverloadedFunctor f2;
-  EXPECT_EQ("&& 42", base_internal::invoke(std::move(f2), " 42"));
-}
-
-TEST(InvokeTest, ReferenceWrapper) {
-  ConstFunctor cf;
-  MutableFunctor mf;
-  EXPECT_EQ(1, base_internal::invoke(std::cref(cf), 3, 2));
-  EXPECT_EQ(1, base_internal::invoke(std::ref(cf), 3, 2));
-  EXPECT_EQ(1, base_internal::invoke(std::ref(mf), 3, 2));
-}
-
-TEST(InvokeTest, MemberFunction) {
-  std::unique_ptr<Class> p(new Class);
-  std::unique_ptr<const Class> cp(new Class);
-  std::unique_ptr<volatile Class> vp(new Class);
-
-  EXPECT_EQ(1, base_internal::invoke(&Class::Method, p, 3, 2));
-  EXPECT_EQ(1, base_internal::invoke(&Class::Method, p.get(), 3, 2));
-  EXPECT_EQ(1, base_internal::invoke(&Class::Method, *p, 3, 2));
-  EXPECT_EQ(1, base_internal::invoke(&Class::RefMethod, p, 3, 2));
-  EXPECT_EQ(1, base_internal::invoke(&Class::RefMethod, p.get(), 3, 2));
-  EXPECT_EQ(1, base_internal::invoke(&Class::RefMethod, *p, 3, 2));
-  EXPECT_EQ(1, base_internal::invoke(&Class::RefRefMethod, std::move(*p), 3,
-                                     2));  // NOLINT
-  EXPECT_EQ(1, base_internal::invoke(&Class::NoExceptMethod, p, 3, 2));
-  EXPECT_EQ(1, base_internal::invoke(&Class::NoExceptMethod, p.get(), 3, 2));
-  EXPECT_EQ(1, base_internal::invoke(&Class::NoExceptMethod, *p, 3, 2));
-
-  EXPECT_EQ(1, base_internal::invoke(&Class::ConstMethod, p, 3, 2));
-  EXPECT_EQ(1, base_internal::invoke(&Class::ConstMethod, p.get(), 3, 2));
-  EXPECT_EQ(1, base_internal::invoke(&Class::ConstMethod, *p, 3, 2));
-
-  EXPECT_EQ(1, base_internal::invoke(&Class::ConstMethod, cp, 3, 2));
-  EXPECT_EQ(1, base_internal::invoke(&Class::ConstMethod, cp.get(), 3, 2));
-  EXPECT_EQ(1, base_internal::invoke(&Class::ConstMethod, *cp, 3, 2));
-
-  EXPECT_EQ(1, base_internal::invoke(&Class::VolatileMethod, p, 3, 2));
-  EXPECT_EQ(1, base_internal::invoke(&Class::VolatileMethod, p.get(), 3, 2));
-  EXPECT_EQ(1, base_internal::invoke(&Class::VolatileMethod, *p, 3, 2));
-  EXPECT_EQ(1, base_internal::invoke(&Class::VolatileMethod, vp, 3, 2));
-  EXPECT_EQ(1, base_internal::invoke(&Class::VolatileMethod, vp.get(), 3, 2));
-  EXPECT_EQ(1, base_internal::invoke(&Class::VolatileMethod, *vp, 3, 2));
-
-  EXPECT_EQ(1,
-            base_internal::invoke(&Class::Method, make_unique<Class>(), 3, 2));
-  EXPECT_EQ(1, base_internal::invoke(&Class::ConstMethod, make_unique<Class>(),
-                                     3, 2));
-  EXPECT_EQ(1, base_internal::invoke(&Class::ConstMethod,
-                                     make_unique<const Class>(), 3, 2));
-}
-
-TEST(InvokeTest, DataMember) {
-  std::unique_ptr<Class> p(new Class{42});
-  std::unique_ptr<const Class> cp(new Class{42});
-  EXPECT_EQ(42, base_internal::invoke(&Class::member, p));
-  EXPECT_EQ(42, base_internal::invoke(&Class::member, *p));
-  EXPECT_EQ(42, base_internal::invoke(&Class::member, p.get()));
-
-  base_internal::invoke(&Class::member, p) = 42;
-  base_internal::invoke(&Class::member, p.get()) = 42;
-
-  EXPECT_EQ(42, base_internal::invoke(&Class::member, cp));
-  EXPECT_EQ(42, base_internal::invoke(&Class::member, *cp));
-  EXPECT_EQ(42, base_internal::invoke(&Class::member, cp.get()));
-}
-
-TEST(InvokeTest, FlipFlop) {
-  FlipFlop obj = {42};
-  // This call could resolve to (obj.*&FlipFlop::ConstMethod)() or
-  // ((*obj).*&FlipFlop::ConstMethod)(). We verify that it's the former.
-  EXPECT_EQ(42, base_internal::invoke(&FlipFlop::ConstMethod, obj));
-  EXPECT_EQ(42, base_internal::invoke(&FlipFlop::member, obj));
-}
-
-TEST(InvokeTest, SfinaeFriendly) {
-  CallMaybeWithArg(NoOp);
-  EXPECT_THAT(CallMaybeWithArg(Factory), ::testing::Pointee(42));
-}
-
-TEST(IsInvocableRTest, CallableExactMatch) {
-  static_assert(
-      base_internal::is_invocable_r<int, decltype(Function), int, int>::value,
-      "Should be true for exact match of types on a free function");
-}
-
-TEST(IsInvocableRTest, CallableArgumentConversionMatch) {
-  static_assert(
-      base_internal::is_invocable_r<int, decltype(Function), char, int>::value,
-      "Should be true for convertible argument type");
-}
-
-TEST(IsInvocableRTest, CallableReturnConversionMatch) {
-  static_assert(base_internal::is_invocable_r<double, decltype(Function), int,
-                                              int>::value,
-                "Should be true for convertible return type");
-}
-
-TEST(IsInvocableRTest, CallableReturnVoid) {
-  static_assert(base_internal::is_invocable_r<void, decltype(VoidFunction),
-                                              int&, int&>::value,
-                "Should be true for void expected and actual return types");
-  static_assert(
-      base_internal::is_invocable_r<void, decltype(Function), int, int>::value,
-      "Should be true for void expected and non-void actual return types");
-}
-
-TEST(IsInvocableRTest, CallableRefQualifierMismatch) {
-  static_assert(!base_internal::is_invocable_r<void, decltype(VoidFunction),
-                                               int&, const int&>::value,
-                "Should be false for reference constness mismatch");
-  static_assert(!base_internal::is_invocable_r<void, decltype(VoidFunction),
-                                               int&&, int&>::value,
-                "Should be false for reference value category mismatch");
-}
-
-TEST(IsInvocableRTest, CallableArgumentTypeMismatch) {
-  static_assert(!base_internal::is_invocable_r<int, decltype(Function),
-                                               std::string, int>::value,
-                "Should be false for argument type mismatch");
-}
-
-TEST(IsInvocableRTest, CallableReturnTypeMismatch) {
-  static_assert(!base_internal::is_invocable_r<std::string, decltype(Function),
-                                               int, int>::value,
-                "Should be false for return type mismatch");
-}
-
-TEST(IsInvocableRTest, CallableTooFewArgs) {
-  static_assert(
-      !base_internal::is_invocable_r<int, decltype(Function), int>::value,
-      "Should be false for too few arguments");
-}
-
-TEST(IsInvocableRTest, CallableTooManyArgs) {
-  static_assert(!base_internal::is_invocable_r<int, decltype(Function), int,
-                                               int, int>::value,
-                "Should be false for too many arguments");
-}
-
-TEST(IsInvocableRTest, MemberFunctionAndReference) {
-  static_assert(base_internal::is_invocable_r<int, decltype(&Class::Method),
-                                              Class&, int, int>::value,
-                "Should be true for exact match of types on a member function "
-                "and class reference");
-}
-
-TEST(IsInvocableRTest, MemberFunctionAndPointer) {
-  static_assert(base_internal::is_invocable_r<int, decltype(&Class::Method),
-                                              Class*, int, int>::value,
-                "Should be true for exact match of types on a member function "
-                "and class pointer");
-}
-
-TEST(IsInvocableRTest, DataMemberAndReference) {
-  static_assert(base_internal::is_invocable_r<int, decltype(&Class::member),
-                                              Class&>::value,
-                "Should be true for exact match of types on a data member and "
-                "class reference");
-}
-
-TEST(IsInvocableRTest, DataMemberAndPointer) {
-  static_assert(base_internal::is_invocable_r<int, decltype(&Class::member),
-                                              Class*>::value,
-                "Should be true for exact match of types on a data member and "
-                "class pointer");
-}
-
-TEST(IsInvocableRTest, CallableZeroArgs) {
-  static_assert(
-      base_internal::is_invocable_r<int, decltype(ZeroArgFunction)>::value,
-      "Should be true for exact match for a zero-arg free function");
-}
-
-}  // namespace
-}  // namespace base_internal
-ABSL_NAMESPACE_END
-}  // namespace absl

package/vendor/abseil-cpp/absl/hash/internal/low_level_hash.cc

@@ -1,148 +0,0 @@
-// Copyright 2020 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/hash/internal/low_level_hash.h"
-
-#include <cstddef>
-#include <cstdint>
-
-#include "absl/base/internal/unaligned_access.h"
-#include "absl/base/prefetch.h"
-#include "absl/numeric/int128.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace hash_internal {
-
-static uint64_t Mix(uint64_t v0, uint64_t v1) {
-  absl::uint128 p = v0;
-  p *= v1;
-  return absl::Uint128Low64(p) ^ absl::Uint128High64(p);
-}
-
-uint64_t LowLevelHashLenGt16(const void* data, size_t len, uint64_t seed,
-                             const uint64_t salt[5]) {
-  const uint8_t* ptr = static_cast<const uint8_t*>(data);
-  uint64_t starting_length = static_cast<uint64_t>(len);
-  const uint8_t* last_16_ptr = ptr + starting_length - 16;
-  uint64_t current_state = seed ^ salt[0];
-
-  if (len > 64) {
-    // If we have more than 64 bytes, we're going to handle chunks of 64
-    // bytes at a time. We're going to build up four separate hash states
-    // which we will then hash together. This avoids short dependency chains.
-    uint64_t duplicated_state0 = current_state;
-    uint64_t duplicated_state1 = current_state;
-    uint64_t duplicated_state2 = current_state;
-
-    do {
-      // Always prefetch the next cacheline.
-      PrefetchToLocalCache(ptr + ABSL_CACHELINE_SIZE);
-
-      uint64_t a = absl::base_internal::UnalignedLoad64(ptr);
-      uint64_t b = absl::base_internal::UnalignedLoad64(ptr + 8);
-      uint64_t c = absl::base_internal::UnalignedLoad64(ptr + 16);
-      uint64_t d = absl::base_internal::UnalignedLoad64(ptr + 24);
-      uint64_t e = absl::base_internal::UnalignedLoad64(ptr + 32);
-      uint64_t f = absl::base_internal::UnalignedLoad64(ptr + 40);
-      uint64_t g = absl::base_internal::UnalignedLoad64(ptr + 48);
-      uint64_t h = absl::base_internal::UnalignedLoad64(ptr + 56);
-
-      current_state = Mix(a ^ salt[1], b ^ current_state);
-      duplicated_state0 = Mix(c ^ salt[2], d ^ duplicated_state0);
-
-      duplicated_state1 = Mix(e ^ salt[3], f ^ duplicated_state1);
-      duplicated_state2 = Mix(g ^ salt[4], h ^ duplicated_state2);
-
-      ptr += 64;
-      len -= 64;
-    } while (len > 64);
-
-    current_state = (current_state ^ duplicated_state0) ^
-                    (duplicated_state1 + duplicated_state2);
-  }
-
-  // We now have a data `ptr` with at most 64 bytes and the current state
-  // of the hashing state machine stored in current_state.
-  if (len > 32) {
-    uint64_t a = absl::base_internal::UnalignedLoad64(ptr);
-    uint64_t b = absl::base_internal::UnalignedLoad64(ptr + 8);
-    uint64_t c = absl::base_internal::UnalignedLoad64(ptr + 16);
-    uint64_t d = absl::base_internal::UnalignedLoad64(ptr + 24);
-
-    uint64_t cs0 = Mix(a ^ salt[1], b ^ current_state);
-    uint64_t cs1 = Mix(c ^ salt[2], d ^ current_state);
-    current_state = cs0 ^ cs1;
-
-    ptr += 32;
-    len -= 32;
-  }
-
-  // We now have a data `ptr` with at most 32 bytes and the current state
-  // of the hashing state machine stored in current_state.
-  if (len > 16) {
-    uint64_t a = absl::base_internal::UnalignedLoad64(ptr);
-    uint64_t b = absl::base_internal::UnalignedLoad64(ptr + 8);
-
-    current_state = Mix(a ^ salt[1], b ^ current_state);
-  }
-
-  // We now have a data `ptr` with at least 1 and at most 16 bytes. But we can
-  // safely read from `ptr + len - 16`.
-  uint64_t a = absl::base_internal::UnalignedLoad64(last_16_ptr);
-  uint64_t b = absl::base_internal::UnalignedLoad64(last_16_ptr + 8);
-
-  return Mix(a ^ salt[1] ^ starting_length, b ^ current_state);
-}
-
-uint64_t LowLevelHash(const void* data, size_t len, uint64_t seed,
-                      const uint64_t salt[5]) {
-  if (len > 16) return LowLevelHashLenGt16(data, len, seed, salt);
-
-  // Prefetch the cacheline that data resides in.
-  PrefetchToLocalCache(data);
-  const uint8_t* ptr = static_cast<const uint8_t*>(data);
-  uint64_t starting_length = static_cast<uint64_t>(len);
-  uint64_t current_state = seed ^ salt[0];
-  if (len == 0) return current_state;
-
-  uint64_t a = 0;
-  uint64_t b = 0;
-
-  // We now have a data `ptr` with at least 1 and at most 16 bytes.
-  if (len > 8) {
-    // When we have at least 9 and at most 16 bytes, set A to the first 64
-    // bits of the input and B to the last 64 bits of the input. Yes, they
-    // will overlap in the middle if we are working with less than the full 16
-    // bytes.
-    a = absl::base_internal::UnalignedLoad64(ptr);
-    b = absl::base_internal::UnalignedLoad64(ptr + len - 8);
-  } else if (len > 3) {
-    // If we have at least 4 and at most 8 bytes, set A to the first 32
-    // bits and B to the last 32 bits.
-    a = absl::base_internal::UnalignedLoad32(ptr);
-    b = absl::base_internal::UnalignedLoad32(ptr + len - 4);
-  } else {
-    // If we have at least 1 and at most 3 bytes, read 2 bytes into A and the
-    // other byte into B, with some adjustments.
-    a = static_cast<uint64_t>((ptr[0] << 8) | ptr[len - 1]);
-    b = static_cast<uint64_t>(ptr[len >> 1]);
-  }
-
-  return Mix(a ^ salt[1] ^ starting_length, b ^ current_state);
-}
-
-}  // namespace hash_internal
-ABSL_NAMESPACE_END
-}  // namespace absl

package/vendor/abseil-cpp/absl/hash/internal/low_level_hash.h

@@ -1,54 +0,0 @@
-// Copyright 2020 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.
-//
-// This file provides the Google-internal implementation of LowLevelHash.
-//
-// LowLevelHash is a fast hash function for hash tables, the fastest we've
-// currently (late 2020) found that passes the SMHasher tests. The algorithm
-// relies on intrinsic 128-bit multiplication for speed. This is not meant to be
-// secure - just fast.
-//
-// It is closely based on a version of wyhash, but does not maintain or
-// guarantee future compatibility with it.
-
-#ifndef ABSL_HASH_INTERNAL_LOW_LEVEL_HASH_H_
-#define ABSL_HASH_INTERNAL_LOW_LEVEL_HASH_H_
-
-#include <stdint.h>
-#include <stdlib.h>
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace hash_internal {
-
-// Hash function for a byte array. A 64-bit seed and a set of five 64-bit
-// integers are hashed into the result.
-//
-// To allow all hashable types (including string_view and Span) to depend on
-// this algorithm, we keep the API low-level, with as few dependencies as
-// possible.
-uint64_t LowLevelHash(const void* data, size_t len, uint64_t seed,
-                      const uint64_t salt[5]);
-
-// Same as above except the length must be greater than 16.
-uint64_t LowLevelHashLenGt16(const void* data, size_t len, uint64_t seed,
-                             const uint64_t salt[5]);
-
-}  // namespace hash_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_HASH_INTERNAL_LOW_LEVEL_HASH_H_

package/vendor/abseil-cpp/absl/random/internal/pool_urbg.h

@@ -1,131 +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_POOL_URBG_H_
-#define ABSL_RANDOM_INTERNAL_POOL_URBG_H_
-
-#include <cinttypes>
-#include <limits>
-
-#include "absl/random/internal/traits.h"
-#include "absl/types/span.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-
-// RandenPool is a thread-safe random number generator [random.req.urbg] that
-// uses an underlying pool of Randen generators to generate values.  Each thread
-// has affinity to one instance of the underlying pool generators.  Concurrent
-// access is guarded by a spin-lock.
-template <typename T>
-class RandenPool {
- public:
-  using result_type = T;
-  static_assert(std::is_unsigned<result_type>::value,
-                "RandenPool template argument must be a built-in unsigned "
-                "integer type");
-
-  static constexpr result_type(min)() {
-    return (std::numeric_limits<result_type>::min)();
-  }
-
-  static constexpr result_type(max)() {
-    return (std::numeric_limits<result_type>::max)();
-  }
-
-  RandenPool() {}
-
-  // Returns a single value.
-  inline result_type operator()() { return Generate(); }
-
-  // Fill data with random values.
-  static void Fill(absl::Span<result_type> data);
-
- protected:
-  // Generate returns a single value.
-  static result_type Generate();
-};
-
-extern template class RandenPool<uint8_t>;
-extern template class RandenPool<uint16_t>;
-extern template class RandenPool<uint32_t>;
-extern template class RandenPool<uint64_t>;
-
-// PoolURBG uses an underlying pool of random generators to implement a
-// thread-compatible [random.req.urbg] interface with an internal cache of
-// values.
-template <typename T, size_t kBufferSize>
-class PoolURBG {
-  // Inheritance to access the protected static members of RandenPool.
-  using unsigned_type = typename make_unsigned_bits<T>::type;
-  using PoolType = RandenPool<unsigned_type>;
-  using SpanType = absl::Span<unsigned_type>;
-
-  static constexpr size_t kInitialBuffer = kBufferSize + 1;
-  static constexpr size_t kHalfBuffer = kBufferSize / 2;
-
- public:
-  using result_type = T;
-
-  static_assert(std::is_unsigned<result_type>::value,
-                "PoolURBG must be parameterized by an unsigned integer type");
-
-  static_assert(kBufferSize > 1,
-                "PoolURBG must be parameterized by a buffer-size > 1");
-
-  static_assert(kBufferSize <= 256,
-                "PoolURBG must be parameterized by a buffer-size <= 256");
-
-  static constexpr result_type(min)() {
-    return (std::numeric_limits<result_type>::min)();
-  }
-
-  static constexpr result_type(max)() {
-    return (std::numeric_limits<result_type>::max)();
-  }
-
-  PoolURBG() : next_(kInitialBuffer) {}
-
-  // copy-constructor does not copy cache.
-  PoolURBG(const PoolURBG&) : next_(kInitialBuffer) {}
-  const PoolURBG& operator=(const PoolURBG&) {
-    next_ = kInitialBuffer;
-    return *this;
-  }
-
-  // move-constructor does move cache.
-  PoolURBG(PoolURBG&&) = default;
-  PoolURBG& operator=(PoolURBG&&) = default;
-
-  inline result_type operator()() {
-    if (next_ >= kBufferSize) {
-      next_ = (kBufferSize > 2 && next_ > kBufferSize) ? kHalfBuffer : 0;
-      PoolType::Fill(SpanType(reinterpret_cast<unsigned_type*>(state_ + next_),
-                              kBufferSize - next_));
-    }
-    return state_[next_++];
-  }
-
- private:
-  // Buffer size.
-  size_t next_;  // index within state_
-  result_type state_[kBufferSize];
-};
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_RANDOM_INTERNAL_POOL_URBG_H_