summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--CMake/Googletest/DownloadGTest.cmake4
-rw-r--r--absl/base/macros.h7
-rw-r--r--absl/container/internal/btree.h11
-rw-r--r--absl/container/internal/common.h3
-rw-r--r--absl/container/internal/container_memory.h7
-rw-r--r--absl/container/internal/container_memory_test.cc38
-rw-r--r--absl/container/internal/raw_hash_set.h5
-rw-r--r--absl/flags/flag_test.cc24
-rw-r--r--absl/flags/internal/flag.cc82
-rw-r--r--absl/flags/internal/flag.h259
-rw-r--r--absl/random/BUILD.bazel5
-rw-r--r--absl/random/CMakeLists.txt3
-rw-r--r--absl/random/bit_gen_ref.h5
-rw-r--r--absl/random/distribution_format_traits.h278
-rw-r--r--absl/random/distributions.h37
-rw-r--r--absl/random/internal/distribution_caller.h15
-rw-r--r--absl/random/internal/mocking_bit_gen_base.h39
-rw-r--r--absl/random/mocking_bit_gen.cc30
-rw-r--r--absl/random/mocking_bit_gen.h8
-rw-r--r--absl/strings/BUILD.bazel1
-rw-r--r--absl/strings/CMakeLists.txt1
-rw-r--r--absl/strings/internal/str_format/arg.cc52
-rw-r--r--absl/strings/internal/str_format/arg.h16
-rw-r--r--absl/strings/internal/str_format/bind.cc2
-rw-r--r--absl/strings/internal/str_format/checker_test.cc10
-rw-r--r--absl/strings/internal/str_format/float_conversion.cc41
-rw-r--r--absl/strings/internal/str_format/parser_test.cc2
-rw-r--r--absl/strings/numbers_test.cc1
-rw-r--r--absl/strings/str_format_test.cc8
29 files changed, 387 insertions, 607 deletions
diff --git a/CMake/Googletest/DownloadGTest.cmake b/CMake/Googletest/DownloadGTest.cmake
index 6552e1da..9d071c91 100644
--- a/CMake/Googletest/DownloadGTest.cmake
+++ b/CMake/Googletest/DownloadGTest.cmake
@@ -38,6 +38,4 @@ set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
# Add googletest directly to our build. This defines the gtest and gtest_main
# targets.
-add_subdirectory(${CMAKE_BINARY_DIR}/googletest-src
- ${CMAKE_BINARY_DIR}/googletest-build
- EXCLUDE_FROM_ALL)
+add_subdirectory(${absl_gtest_src_dir} ${absl_gtest_build_dir} EXCLUDE_FROM_ALL)
diff --git a/absl/base/macros.h b/absl/base/macros.h
index 2f6089f4..2c4e3570 100644
--- a/absl/base/macros.h
+++ b/absl/base/macros.h
@@ -212,7 +212,8 @@ ABSL_NAMESPACE_END
// aborts the program in release mode (when NDEBUG is defined). The
// implementation should abort the program as quickly as possible and ideally it
// should not be possible to ignore the abort request.
-#if ABSL_HAVE_BUILTIN(__builtin_trap) || \
+#if (ABSL_HAVE_BUILTIN(__builtin_trap) && \
+ ABSL_HAVE_BUILTIN(__builtin_unreachable)) || \
(defined(__GNUC__) && !defined(__clang__))
#define ABSL_INTERNAL_HARDENING_ABORT() \
do { \
@@ -225,11 +226,11 @@ ABSL_NAMESPACE_END
// ABSL_HARDENING_ASSERT()
//
-// `ABSL_HARDENED_ASSERT()` is like `ABSL_ASSERT()`, but used to implement
+// `ABSL_HARDENING_ASSERT()` is like `ABSL_ASSERT()`, but used to implement
// runtime assertions that should be enabled in hardened builds even when
// `NDEBUG` is defined.
//
-// When `NDEBUG` is not defined, `ABSL_HARDENED_ASSERT()` is identical to
+// When `NDEBUG` is not defined, `ABSL_HARDENING_ASSERT()` is identical to
// `ABSL_ASSERT()`.
//
// See `ABSL_OPTION_HARDENED` in `absl/base/options.h` for more information on
diff --git a/absl/container/internal/btree.h b/absl/container/internal/btree.h
index adf49f81..4504e9ce 100644
--- a/absl/container/internal/btree.h
+++ b/absl/container/internal/btree.h
@@ -937,8 +937,13 @@ struct btree_iterator {
}
// Accessors for the key/value the iterator is pointing at.
- reference operator*() const { return node->value(position); }
- pointer operator->() const { return &node->value(position); }
+ reference operator*() const {
+ ABSL_HARDENING_ASSERT(node != nullptr);
+ ABSL_HARDENING_ASSERT(node->start() <= position);
+ ABSL_HARDENING_ASSERT(node->finish() > position);
+ return node->value(position);
+ }
+ pointer operator->() const { return &operator*(); }
btree_iterator &operator++() {
increment();
@@ -1769,6 +1774,7 @@ void btree_iterator<N, R, P>::increment_slow() {
position = node->position();
node = node->parent();
}
+ // TODO(ezb): assert we aren't incrementing end() instead of handling.
if (position == node->finish()) {
*this = save;
}
@@ -1792,6 +1798,7 @@ void btree_iterator<N, R, P>::decrement_slow() {
position = node->position() - 1;
node = node->parent();
}
+ // TODO(ezb): assert we aren't decrementing begin() instead of handling.
if (position < node->start()) {
*this = save;
}
diff --git a/absl/container/internal/common.h b/absl/container/internal/common.h
index 5037d803..8990f294 100644
--- a/absl/container/internal/common.h
+++ b/absl/container/internal/common.h
@@ -138,6 +138,7 @@ class node_handle<Policy, PolicyTraits, Alloc,
absl::void_t<typename Policy::mapped_type>>
: public node_handle_base<PolicyTraits, Alloc> {
using Base = node_handle_base<PolicyTraits, Alloc>;
+ using slot_type = typename PolicyTraits::slot_type;
public:
using key_type = typename Policy::key_type;
@@ -145,7 +146,7 @@ class node_handle<Policy, PolicyTraits, Alloc,
constexpr node_handle() {}
- auto key() const -> decltype(PolicyTraits::key(this->slot())) {
+ auto key() const -> decltype(PolicyTraits::key(std::declval<slot_type*>())) {
return PolicyTraits::key(this->slot());
}
diff --git a/absl/container/internal/container_memory.h b/absl/container/internal/container_memory.h
index d24b0f84..55b59c7f 100644
--- a/absl/container/internal/container_memory.h
+++ b/absl/container/internal/container_memory.h
@@ -37,6 +37,9 @@ namespace absl {
ABSL_NAMESPACE_BEGIN
namespace container_internal {
+template <size_t Alignment>
+struct alignas(Alignment) AlignedType {};
+
// Allocates at least n bytes aligned to the specified alignment.
// Alignment must be a power of 2. It must be positive.
//
@@ -48,7 +51,7 @@ template <size_t Alignment, class Alloc>
void* Allocate(Alloc* alloc, size_t n) {
static_assert(Alignment > 0, "");
assert(n && "n must be positive");
- struct alignas(Alignment) M {};
+ using M = AlignedType<Alignment>;
using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
A mem_alloc(*alloc);
@@ -64,7 +67,7 @@ template <size_t Alignment, class Alloc>
void Deallocate(Alloc* alloc, void* p, size_t n) {
static_assert(Alignment > 0, "");
assert(n && "n must be positive");
- struct alignas(Alignment) M {};
+ using M = AlignedType<Alignment>;
using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
A mem_alloc(*alloc);
diff --git a/absl/container/internal/container_memory_test.cc b/absl/container/internal/container_memory_test.cc
index 7942c7be..e3262e3c 100644
--- a/absl/container/internal/container_memory_test.cc
+++ b/absl/container/internal/container_memory_test.cc
@@ -16,6 +16,8 @@
#include <cstdint>
#include <tuple>
+#include <typeindex>
+#include <typeinfo>
#include <utility>
#include "gmock/gmock.h"
@@ -27,6 +29,9 @@ ABSL_NAMESPACE_BEGIN
namespace container_internal {
namespace {
+using ::testing::Gt;
+using ::testing::_;
+using ::testing::ElementsAre;
using ::testing::Pair;
TEST(Memory, AlignmentLargerThanBase) {
@@ -45,6 +50,39 @@ TEST(Memory, AlignmentSmallerThanBase) {
Deallocate<2>(&alloc, mem, 3);
}
+std::map<std::type_index, int>& AllocationMap() {
+ static auto* map = new std::map<std::type_index, int>;
+ return *map;
+}
+
+template <typename T>
+struct TypeCountingAllocator {
+ TypeCountingAllocator() = default;
+ template <typename U>
+ TypeCountingAllocator(const TypeCountingAllocator<U>&) {} // NOLINT
+
+ using value_type = T;
+
+ T* allocate(size_t n, const void* = nullptr) {
+ AllocationMap()[typeid(T)] += n;
+ return std::allocator<T>().allocate(n);
+ }
+ void deallocate(T* p, std::size_t n) {
+ AllocationMap()[typeid(T)] -= n;
+ return std::allocator<T>().deallocate(p, n);
+ }
+};
+
+TEST(Memory, AllocateDeallocateMatchType) {
+ TypeCountingAllocator<int> alloc;
+ void* mem = Allocate<1>(&alloc, 1);
+ // Verify that it was allocated
+ EXPECT_THAT(AllocationMap(), ElementsAre(Pair(_, Gt(0))));
+ Deallocate<1>(&alloc, mem, 1);
+ // Verify that the deallocation matched.
+ EXPECT_THAT(AllocationMap(), ElementsAre(Pair(_, 0)));
+}
+
class Fixture : public ::testing::Test {
using Alloc = std::allocator<std::string>;
diff --git a/absl/container/internal/raw_hash_set.h b/absl/container/internal/raw_hash_set.h
index fb47f62f..e47e1fed 100644
--- a/absl/container/internal/raw_hash_set.h
+++ b/absl/container/internal/raw_hash_set.h
@@ -104,6 +104,7 @@
#include "absl/base/internal/bits.h"
#include "absl/base/internal/endian.h"
+#include "absl/base/macros.h"
#include "absl/base/port.h"
#include "absl/container/internal/common.h"
#include "absl/container/internal/compressed_tuple.h"
@@ -651,9 +652,9 @@ class raw_hash_set {
iterator(ctrl_t* ctrl) : ctrl_(ctrl) {} // for end()
iterator(ctrl_t* ctrl, slot_type* slot) : ctrl_(ctrl), slot_(slot) {}
- void assert_is_full() const { assert(IsFull(*ctrl_)); }
+ void assert_is_full() const { ABSL_HARDENING_ASSERT(IsFull(*ctrl_)); }
void assert_is_valid() const {
- assert(!ctrl_ || IsFull(*ctrl_) || *ctrl_ == kSentinel);
+ ABSL_HARDENING_ASSERT(!ctrl_ || IsFull(*ctrl_) || *ctrl_ == kSentinel);
}
void skip_empty_or_deleted() {
diff --git a/absl/flags/flag_test.cc b/absl/flags/flag_test.cc
index 3a025576..377e3b2b 100644
--- a/absl/flags/flag_test.cc
+++ b/absl/flags/flag_test.cc
@@ -91,30 +91,30 @@ struct S2 {
};
TEST_F(FlagTest, Traits) {
- EXPECT_EQ(flags::FlagValue::Kind<int>(),
+ EXPECT_EQ(flags::StorageKind<int>(),
flags::FlagValueStorageKind::kOneWordAtomic);
- EXPECT_EQ(flags::FlagValue::Kind<bool>(),
+ EXPECT_EQ(flags::StorageKind<bool>(),
flags::FlagValueStorageKind::kOneWordAtomic);
- EXPECT_EQ(flags::FlagValue::Kind<double>(),
+ EXPECT_EQ(flags::StorageKind<double>(),
flags::FlagValueStorageKind::kOneWordAtomic);
- EXPECT_EQ(flags::FlagValue::Kind<int64_t>(),
+ EXPECT_EQ(flags::StorageKind<int64_t>(),
flags::FlagValueStorageKind::kOneWordAtomic);
#if defined(ABSL_FLAGS_INTERNAL_ATOMIC_DOUBLE_WORD)
- EXPECT_EQ(flags::FlagValue::Kind<S1>(),
+ EXPECT_EQ(flags::StorageKind<S1>(),
flags::FlagValueStorageKind::kTwoWordsAtomic);
- EXPECT_EQ(flags::FlagValue::Kind<S2>(),
+ EXPECT_EQ(flags::StorageKind<S2>(),
flags::FlagValueStorageKind::kTwoWordsAtomic);
#else
- EXPECT_EQ(flags::FlagValue::Kind<S1>(),
+ EXPECT_EQ(flags::StorageKind<S1>(),
flags::FlagValueStorageKind::kHeapAllocated);
- EXPECT_EQ(flags::FlagValue::Kind<S2>(),
+ EXPECT_EQ(flags::StorageKind<S2>(),
flags::FlagValueStorageKind::kHeapAllocated);
#endif
- EXPECT_EQ(flags::FlagValue::Kind<std::string>(),
+ EXPECT_EQ(flags::StorageKind<std::string>(),
flags::FlagValueStorageKind::kHeapAllocated);
- EXPECT_EQ(flags::FlagValue::Kind<std::vector<std::string>>(),
+ EXPECT_EQ(flags::StorageKind<std::vector<std::string>>(),
flags::FlagValueStorageKind::kHeapAllocated);
}
@@ -624,10 +624,10 @@ TEST_F(FlagTest, TestNonDefaultConstructibleType) {
EXPECT_EQ(absl::GetFlag(FLAGS_ndc_flag2).value, 25);
}
-// --------------------------------------------------------------------
-
} // namespace
+// --------------------------------------------------------------------
+
ABSL_RETIRED_FLAG(bool, old_bool_flag, true, "old descr");
ABSL_RETIRED_FLAG(int, old_int_flag, (int)std::sqrt(10), "old descr");
ABSL_RETIRED_FLAG(std::string, old_str_flag, "", absl::StrCat("old ", "descr"));
diff --git a/absl/flags/internal/flag.cc b/absl/flags/internal/flag.cc
index 56a5ed2b..5b4499ab 100644
--- a/absl/flags/internal/flag.cc
+++ b/absl/flags/internal/flag.cc
@@ -25,6 +25,7 @@
#include <vector>
#include "absl/base/attributes.h"
+#include "absl/base/casts.h"
#include "absl/base/config.h"
#include "absl/base/const_init.h"
#include "absl/base/optimization.h"
@@ -135,18 +136,18 @@ void FlagImpl::Init() {
(*default_value_.gen_func)(), DynValueDeleter{op_});
switch (ValueStorageKind()) {
case FlagValueStorageKind::kHeapAllocated:
- value_.dynamic = init_value.release();
+ HeapAllocatedValue() = init_value.release();
break;
case FlagValueStorageKind::kOneWordAtomic: {
int64_t atomic_value;
- std::memcpy(&atomic_value, init_value.get(), flags_internal::Sizeof(op_));
- value_.one_word_atomic.store(atomic_value, std::memory_order_release);
+ std::memcpy(&atomic_value, init_value.get(), Sizeof(op_));
+ OneWordValue().store(atomic_value, std::memory_order_release);
break;
}
case FlagValueStorageKind::kTwoWordsAtomic: {
AlignedTwoWords atomic_value{0, 0};
- std::memcpy(&atomic_value, init_value.get(), flags_internal::Sizeof(op_));
- value_.two_words_atomic.store(atomic_value, std::memory_order_release);
+ std::memcpy(&atomic_value, init_value.get(), Sizeof(op_));
+ TwoWordsValue().store(atomic_value, std::memory_order_release);
break;
}
}
@@ -198,18 +199,18 @@ std::unique_ptr<void, DynValueDeleter> FlagImpl::MakeInitValue() const {
void FlagImpl::StoreValue(const void* src) {
switch (ValueStorageKind()) {
case FlagValueStorageKind::kHeapAllocated:
- flags_internal::Copy(op_, src, value_.dynamic);
+ Copy(op_, src, HeapAllocatedValue());
break;
case FlagValueStorageKind::kOneWordAtomic: {
- int64_t one_word_val;
- std::memcpy(&one_word_val, src, flags_internal::Sizeof(op_));
- value_.one_word_atomic.store(one_word_val, std::memory_order_release);
+ int64_t one_word_val = 0;
+ std::memcpy(&one_word_val, src, Sizeof(op_));
+ OneWordValue().store(one_word_val, std::memory_order_release);
break;
}
case FlagValueStorageKind::kTwoWordsAtomic: {
AlignedTwoWords two_words_val{0, 0};
- std::memcpy(&two_words_val, src, flags_internal::Sizeof(op_));
- value_.two_words_atomic.store(two_words_val, std::memory_order_release);
+ std::memcpy(&two_words_val, src, Sizeof(op_));
+ TwoWordsValue().store(two_words_val, std::memory_order_release);
break;
}
}
@@ -258,17 +259,19 @@ std::string FlagImpl::CurrentValue() const {
switch (ValueStorageKind()) {
case FlagValueStorageKind::kHeapAllocated: {
absl::MutexLock l(guard);
- return flags_internal::Unparse(op_, value_.dynamic);
+ return flags_internal::Unparse(op_, HeapAllocatedValue());
}
case FlagValueStorageKind::kOneWordAtomic: {
const auto one_word_val =
- value_.one_word_atomic.load(std::memory_order_acquire);
- return flags_internal::Unparse(op_, &one_word_val);
+ absl::bit_cast<std::array<char, sizeof(int64_t)>>(
+ OneWordValue().load(std::memory_order_acquire));
+ return flags_internal::Unparse(op_, one_word_val.data());
}
case FlagValueStorageKind::kTwoWordsAtomic: {
const auto two_words_val =
- value_.two_words_atomic.load(std::memory_order_acquire);
- return flags_internal::Unparse(op_, &two_words_val);
+ absl::bit_cast<std::array<char, sizeof(AlignedTwoWords)>>(
+ TwoWordsValue().load(std::memory_order_acquire));
+ return flags_internal::Unparse(op_, two_words_val.data());
}
}
@@ -317,18 +320,18 @@ std::unique_ptr<FlagStateInterface> FlagImpl::SaveState() {
switch (ValueStorageKind()) {
case FlagValueStorageKind::kHeapAllocated: {
return absl::make_unique<FlagState>(
- this, flags_internal::Clone(op_, value_.dynamic), modified,
+ this, flags_internal::Clone(op_, HeapAllocatedValue()), modified,
on_command_line, counter_);
}
case FlagValueStorageKind::kOneWordAtomic: {
return absl::make_unique<FlagState>(
- this, value_.one_word_atomic.load(std::memory_order_acquire),
- modified, on_command_line, counter_);
+ this, OneWordValue().load(std::memory_order_acquire), modified,
+ on_command_line, counter_);
}
case FlagValueStorageKind::kTwoWordsAtomic: {
return absl::make_unique<FlagState>(
- this, value_.two_words_atomic.load(std::memory_order_acquire),
- modified, on_command_line, counter_);
+ this, TwoWordsValue().load(std::memory_order_acquire), modified,
+ on_command_line, counter_);
}
}
return nullptr;
@@ -359,6 +362,28 @@ bool FlagImpl::RestoreState(const FlagState& flag_state) {
return true;
}
+template <typename StorageT>
+typename StorageT::value_type& FlagImpl::OffsetValue() const {
+ char* p = reinterpret_cast<char*>(const_cast<FlagImpl*>(this));
+ // The offset is deduced via Flag value type specific op_.
+ size_t offset = flags_internal::ValueOffset(op_);
+
+ return reinterpret_cast<StorageT*>(p + offset)->value;
+}
+
+void*& FlagImpl::HeapAllocatedValue() const {
+ assert(ValueStorageKind() == FlagValueStorageKind::kHeapAllocated);
+ return OffsetValue<FlagHeapAllocatedValue>();
+}
+std::atomic<int64_t>& FlagImpl::OneWordValue() const {
+ assert(ValueStorageKind() == FlagValueStorageKind::kOneWordAtomic);
+ return OffsetValue<FlagOneWordValue>();
+}
+std::atomic<AlignedTwoWords>& FlagImpl::TwoWordsValue() const {
+ assert(ValueStorageKind() == FlagValueStorageKind::kTwoWordsAtomic);
+ return OffsetValue<FlagTwoWordsValue>();
+}
+
// Attempts to parse supplied `value` string using parsing routine in the `flag`
// argument. If parsing successful, this function replaces the dst with newly
// parsed value. In case if any error is encountered in either step, the error
@@ -383,20 +408,19 @@ void FlagImpl::Read(void* dst) const {
switch (ValueStorageKind()) {
case FlagValueStorageKind::kHeapAllocated: {
absl::MutexLock l(guard);
-
- flags_internal::CopyConstruct(op_, value_.dynamic, dst);
+ flags_internal::CopyConstruct(op_, HeapAllocatedValue(), dst);
break;
}
case FlagValueStorageKind::kOneWordAtomic: {
- const auto one_word_val =
- value_.one_word_atomic.load(std::memory_order_acquire);
- std::memcpy(dst, &one_word_val, flags_internal::Sizeof(op_));
+ const int64_t one_word_val =
+ OneWordValue().load(std::memory_order_acquire);
+ std::memcpy(dst, &one_word_val, Sizeof(op_));
break;
}
case FlagValueStorageKind::kTwoWordsAtomic: {
- const auto two_words_val =
- value_.two_words_atomic.load(std::memory_order_acquire);
- std::memcpy(dst, &two_words_val, flags_internal::Sizeof(op_));
+ const AlignedTwoWords two_words_val =
+ TwoWordsValue().load(std::memory_order_acquire);
+ std::memcpy(dst, &two_words_val, Sizeof(op_));
break;
}
}
diff --git a/absl/flags/internal/flag.h b/absl/flags/internal/flag.h
index f27e558b..19119bbb 100644
--- a/absl/flags/internal/flag.h
+++ b/absl/flags/internal/flag.h
@@ -53,56 +53,13 @@ enum class FlagOp {
kStaticTypeId,
kParse,
kUnparse,
+ kValueOffset,
};
using FlagOpFn = void* (*)(FlagOp, const void*, void*, void*);
-// Flag value specific operations routine.
+// Forward declaration for Flag value specific operations.
template <typename T>
-void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
- switch (op) {
- case FlagOp::kDelete:
- delete static_cast<const T*>(v1);
- return nullptr;
- case FlagOp::kClone:
- return new T(*static_cast<const T*>(v1));
- case FlagOp::kCopy:
- *static_cast<T*>(v2) = *static_cast<const T*>(v1);
- return nullptr;
- case FlagOp::kCopyConstruct:
- new (v2) T(*static_cast<const T*>(v1));
- return nullptr;
- case FlagOp::kSizeof:
- return reinterpret_cast<void*>(sizeof(T));
- case FlagOp::kStaticTypeId: {
- auto* static_id = &FlagStaticTypeIdGen<T>;
-
- // Cast from function pointer to void* is not portable.
- // We don't have an easy way to work around this, but it works fine
- // on all the platforms we test and as long as size of pointers match
- // we should be fine to do reinterpret cast.
- static_assert(sizeof(void*) == sizeof(static_id),
- "Flag's static type id does not work on this platform");
- return reinterpret_cast<void*>(static_id);
- }
- case FlagOp::kParse: {
- // Initialize the temporary instance of type T based on current value in
- // destination (which is going to be flag's default value).
- T temp(*static_cast<T*>(v2));
- if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp,
- static_cast<std::string*>(v3))) {
- return nullptr;
- }
- *static_cast<T*>(v2) = std::move(temp);
- return v2;
- }
- case FlagOp::kUnparse:
- *static_cast<std::string*>(v2) =
- absl::UnparseFlag<T>(*static_cast<const T*>(v1));
- return nullptr;
- default:
- return nullptr;
- }
-}
+void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3);
// Deletes memory interpreting obj as flag value type pointer.
inline void Delete(FlagOpFn op, const void* obj) {
@@ -144,6 +101,16 @@ inline FlagStaticTypeId StaticTypeId(FlagOpFn op) {
return reinterpret_cast<FlagStaticTypeId>(
op(FlagOp::kStaticTypeId, nullptr, nullptr, nullptr));
}
+// Returns offset of the field value_ from the field impl_ inside of
+// absl::Flag<T> data. Given FlagImpl pointer p you can get the
+// location of the corresponding value as:
+// reinterpret_cast<char*>(p) + ValueOffset().
+inline ptrdiff_t ValueOffset(FlagOpFn op) {
+ // This sequence of casts reverses the sequence from
+ // `flags_internal::FlagOps()`
+ return static_cast<ptrdiff_t>(reinterpret_cast<intptr_t>(
+ op(FlagOp::kValueOffset, nullptr, nullptr, nullptr)));
+}
///////////////////////////////////////////////////////////////////////////////
// Flag help auxiliary structs.
@@ -239,6 +206,10 @@ using FlagUseOneWordStorage = std::integral_constant<
struct alignas(16) AlignedTwoWords {
int64_t first;
int64_t second;
+
+ bool IsInitialized() const {
+ return first != flags_internal::UninitializedFlagValue();
+ }
};
template <typename T>
@@ -248,8 +219,14 @@ using FlagUseTwoWordsStorage = std::integral_constant<
#else
// This is actually unused and only here to avoid ifdefs in other palces.
struct AlignedTwoWords {
- constexpr AlignedTwoWords() = default;
- constexpr AlignedTwoWords(int64_t, int64_t) {}
+ constexpr AlignedTwoWords() noexcept : dummy() {}
+ constexpr AlignedTwoWords(int64_t, int64_t) noexcept : dummy() {}
+ char dummy;
+
+ bool IsInitialized() const {
+ std::abort();
+ return true;
+ }
};
// This trait should be type dependent, otherwise SFINAE below will fail
@@ -269,23 +246,70 @@ enum class FlagValueStorageKind : uint8_t {
kTwoWordsAtomic = 2
};
-union FlagValue {
- constexpr explicit FlagValue(int64_t v) : one_word_atomic(v) {}
+template <typename T>
+static constexpr FlagValueStorageKind StorageKind() {
+ return FlagUseHeapStorage<T>::value
+ ? FlagValueStorageKind::kHeapAllocated
+ : FlagUseOneWordStorage<T>::value
+ ? FlagValueStorageKind::kOneWordAtomic
+ : FlagUseTwoWordsStorage<T>::value
+ ? FlagValueStorageKind::kTwoWordsAtomic
+ : FlagValueStorageKind::kHeapAllocated;
+}
+
+struct FlagHeapAllocatedValue {
+ using value_type = void*;
+
+ value_type value;
+};
+
+struct FlagOneWordValue {
+ using value_type = std::atomic<int64_t>;
+ constexpr FlagOneWordValue() : value(UninitializedFlagValue()) {}
- template <typename T>
- static constexpr FlagValueStorageKind Kind() {
- return FlagUseHeapStorage<T>::value
- ? FlagValueStorageKind::kHeapAllocated
- : FlagUseOneWordStorage<T>::value
- ? FlagValueStorageKind::kOneWordAtomic
- : FlagUseTwoWordsStorage<T>::value
- ? FlagValueStorageKind::kTwoWordsAtomic
- : FlagValueStorageKind::kHeapAllocated;
+ value_type value;
+};
+
+struct FlagTwoWordsValue {
+ using value_type = std::atomic<AlignedTwoWords>;
+ constexpr FlagTwoWordsValue()
+ : value(AlignedTwoWords{UninitializedFlagValue(), 0}) {}
+
+ value_type value;
+};
+
+template <typename T,
+ FlagValueStorageKind Kind = flags_internal::StorageKind<T>()>
+struct FlagValue;
+
+template <typename T>
+struct FlagValue<T, FlagValueStorageKind::kHeapAllocated>
+ : FlagHeapAllocatedValue {
+ bool Get(T*) const { return false; }
+};
+
+template <typename T>
+struct FlagValue<T, FlagValueStorageKind::kOneWordAtomic> : FlagOneWordValue {
+ bool Get(T* dst) const {
+ int64_t one_word_val = value.load(std::memory_order_acquire);
+ if (ABSL_PREDICT_FALSE(one_word_val == UninitializedFlagValue())) {
+ return false;
+ }
+ std::memcpy(dst, static_cast<const void*>(&one_word_val), sizeof(T));
+ return true;
}
+};
- void* dynamic;
- std::atomic<int64_t> one_word_atomic;
- std::atomic<flags_internal::AlignedTwoWords> two_words_atomic;
+template <typename T>
+struct FlagValue<T, FlagValueStorageKind::kTwoWordsAtomic> : FlagTwoWordsValue {
+ bool Get(T* dst) const {
+ AlignedTwoWords two_words_val = value.load(std::memory_order_acquire);
+ if (ABSL_PREDICT_FALSE(!two_words_val.IsInitialized())) {
+ return false;
+ }
+ std::memcpy(dst, static_cast<const void*>(&two_words_val), sizeof(T));
+ return true;
+ }
};
///////////////////////////////////////////////////////////////////////////////
@@ -333,35 +357,10 @@ class FlagImpl final : public flags_internal::CommandLineFlag {
counter_(0),
callback_(nullptr),
default_value_(default_value_gen),
- value_(flags_internal::UninitializedFlagValue()),
data_guard_{} {}
// Constant access methods
void Read(void* dst) const override ABSL_LOCKS_EXCLUDED(*DataGuard());
- template <typename T, typename std::enable_if<FlagUseHeapStorage<T>::value,
- int>::type = 0>
- void Get(T* dst) const {
- Read(dst);
- }
- template <typename T, typename std::enable_if<FlagUseOneWordStorage<T>::value,
- int>::type = 0>
- void Get(T* dst) const {
- int64_t one_word_val =
- value_.one_word_atomic.load(std::memory_order_acquire);
- if (ABSL_PREDICT_FALSE(one_word_val == UninitializedFlagValue())) {
- DataGuard(); // Make sure flag initialized
- one_word_val = value_.one_word_atomic.load(std::memory_order_acquire);
- }
- std::memcpy(dst, static_cast<const void*>(&one_word_val), sizeof(T));
- }
- template <typename T, typename std::enable_if<
- FlagUseTwoWordsStorage<T>::value, int>::type = 0>
- void Get(T* dst) const {
- DataGuard(); // Make sure flag initialized
- const auto two_words_val =
- value_.two_words_atomic.load(std::memory_order_acquire);
- std::memcpy(dst, &two_words_val, sizeof(T));
- }
// Mutating access methods
void Write(const void* src) ABSL_LOCKS_EXCLUDED(*DataGuard());
@@ -391,6 +390,25 @@ class FlagImpl final : public flags_internal::CommandLineFlag {
ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
// Flag initialization called via absl::call_once.
void Init();
+
+ // Offset value access methods. One per storage kind. These methods to not
+ // respect const correctness, so be very carefull using them.
+
+ // This is a shared helper routine which encapsulates most of the magic. Since
+ // it is only used inside the three routines below, which are defined in
+ // flag.cc, we can define it in that file as well.
+ template <typename StorageT>
+ typename StorageT::value_type& OffsetValue() const;
+ // This is an accessor for a value stored in heap allocated storage.
+ // Returns a mutable reference to a pointer to allow vlaue mutation.
+ void*& HeapAllocatedValue() const;
+ // This is an accessor for a value stored as one word atomic. Returns a
+ // mutable reference to an atomic value.
+ std::atomic<int64_t>& OneWordValue() const;
+ // This is an accessor for a value stored as two words atomic. Returns a
+ // mutable reference to an atomic value.
+ std::atomic<AlignedTwoWords>& TwoWordsValue() const;
+
// Attempts to parse supplied `value` string. If parsing is successful,
// returns new value. Otherwise returns nullptr.
std::unique_ptr<void, DynValueDeleter> TryParse(absl::string_view value,
@@ -488,13 +506,6 @@ class FlagImpl final : public flags_internal::CommandLineFlag {
// these two cases.
FlagDefaultSrc default_value_;
- // Atomically mutable flag's state
-
- // Flag's value. This can be either the atomically stored small value or
- // pointer to the heap allocated dynamic value. value_storage_kind_ is used
- // to distinguish these cases.
- FlagValue value_;
-
// This is reserved space for an absl::Mutex to guard flag data. It will be
// initialized in FlagImpl::Init via placement new.
// We can't use "absl::Mutex data_guard_", since this class is not literal.
@@ -514,8 +525,9 @@ class Flag {
public:
constexpr Flag(const char* name, const char* filename, const FlagHelpArg help,
const FlagDfltGenFunc default_value_gen)
- : impl_(name, filename, &FlagOps<T>, help, FlagValue::Kind<T>(),
- default_value_gen) {}
+ : impl_(name, filename, &FlagOps<T>, help,
+ flags_internal::StorageKind<T>(), default_value_gen),
+ value_() {}
T Get() const {
// See implementation notes in CommandLineFlag::Get().
@@ -530,7 +542,7 @@ class Flag {
impl_.AssertValidType(&flags_internal::FlagStaticTypeIdGen<T>);
#endif
- impl_.Get(&u.value);
+ if (!value_.Get(&u.value)) impl_.Read(&u.value);
return std::move(u.value);
}
void Set(const T& v) {
@@ -556,10 +568,63 @@ class Flag {
private:
template <typename U, bool do_register>
friend class FlagRegistrar;
+
// Flag's data
+ // The implementation depends on value_ field to be placed exactly after the
+ // impl_ field, so that impl_ can figure out the offset to the value and
+ // access it.
FlagImpl impl_;
+ FlagValue<T> value_;
};
+///////////////////////////////////////////////////////////////////////////////
+// Implementation of Flag value specific operations routine.
+template <typename T>
+void* FlagOps(FlagOp op, const void* v1, void* v2, void* v3) {
+ switch (op) {
+ case FlagOp::kDelete:
+ delete static_cast<const T*>(v1);
+ return nullptr;
+ case FlagOp::kClone:
+ return new T(*static_cast<const T*>(v1));
+ case FlagOp::kCopy:
+ *static_cast<T*>(v2) = *static_cast<const T*>(v1);
+ return nullptr;
+ case FlagOp::kCopyConstruct:
+ new (v2) T(*static_cast<const T*>(v1));
+ return nullptr;
+ case FlagOp::kSizeof:
+ return reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(T)));
+ case FlagOp::kStaticTypeId:
+ return reinterpret_cast<void*>(&FlagStaticTypeIdGen<T>);
+ case FlagOp::kParse: {
+ // Initialize the temporary instance of type T based on current value in
+ // destination (which is going to be flag's default value).
+ T temp(*static_cast<T*>(v2));
+ if (!absl::ParseFlag<T>(*static_cast<const absl::string_view*>(v1), &temp,
+ static_cast<std::string*>(v3))) {
+ return nullptr;
+ }
+ *static_cast<T*>(v2) = std::move(temp);
+ return v2;
+ }
+ case FlagOp::kUnparse:
+ *static_cast<std::string*>(v2) =
+ absl::UnparseFlag<T>(*static_cast<const T*>(v1));
+ return nullptr;
+ case FlagOp::kValueOffset: {
+ // Round sizeof(FlagImp) to a multiple of alignof(FlagValue<T>) to get the
+ // offset of the data.
+ ptrdiff_t round_to = alignof(FlagValue<T>);
+ ptrdiff_t offset =
+ (sizeof(FlagImpl) + round_to - 1) / round_to * round_to;
+ return reinterpret_cast<void*>(offset);
+ }
+ }
+ return nullptr;
+}
+
+///////////////////////////////////////////////////////////////////////////////
// This class facilitates Flag object registration and tail expression-based
// flag definition, for example:
// ABSL_FLAG(int, foo, 42, "Foo help").OnUpdate(NotifyFooWatcher);
diff --git a/absl/random/BUILD.bazel b/absl/random/BUILD.bazel
index f78fbc7e..4d94e1ba 100644
--- a/absl/random/BUILD.bazel
+++ b/absl/random/BUILD.bazel
@@ -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",
diff --git a/absl/random/CMakeLists.txt b/absl/random/CMakeLists.txt
index efa55d8f..69bedbd6 100644
--- a/absl/random/CMakeLists.txt
+++ b/absl/random/CMakeLists.txt
@@ -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"
diff --git a/absl/random/bit_gen_ref.h b/absl/random/bit_gen_ref.h
index e8771162..59591a47 100644
--- a/absl/random/bit_gen_ref.h
+++ b/absl/random/bit_gen_ref.h
@@ -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)...);
}
}
};
diff --git a/absl/random/distribution_format_traits.h b/absl/random/distribution_format_traits.h
deleted file mode 100644
index 22b358cc..00000000
--- a/absl/random/distribution_format_traits.h
+++ /dev/null
@@ -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_
diff --git a/absl/random/distributions.h b/absl/random/distributions.h
index d026d92b..8680f6a6 100644
--- a/absl/random/distributions.h
+++ b/absl/random/distributions.h
@@ -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
diff --git a/absl/random/internal/distribution_caller.h b/absl/random/internal/distribution_caller.h
index 02603cf8..4e072444 100644
--- a/absl/random/internal/distribution_caller.h
+++ b/absl/random/internal/distribution_caller.h
@@ -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);
diff --git a/absl/random/internal/mocking_bit_gen_base.h b/absl/random/internal/mocking_bit_gen_base.h
index eeeae9d2..23ecaf6c 100644
--- a/absl/random/internal/mocking_bit_gen_base.h
+++ b/absl/random/internal/mocking_bit_gen_base.h
@@ -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
diff --git a/absl/random/mocking_bit_gen.cc b/absl/random/mocking_bit_gen.cc
deleted file mode 100644
index 6bb1e414..00000000
--- a/absl/random/mocking_bit_gen.cc
+++ /dev/null
@@ -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
diff --git a/absl/random/mocking_bit_gen.h b/absl/random/mocking_bit_gen.h
index 36cef911..3d8a979e 100644
--- a/absl/random/mocking_bit_gen.h
+++ b/absl/random/mocking_bit_gen.h
@@ -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)...);
}
};
diff --git a/absl/strings/BUILD.bazel b/absl/strings/BUILD.bazel
index e72db82c..64f55fb4 100644
--- a/absl/strings/BUILD.bazel
+++ b/absl/strings/BUILD.bazel
@@ -485,6 +485,7 @@ cc_test(
copts = ABSL_TEST_COPTS,
visibility = ["//visibility:private"],
deps = [
+ ":internal",
":pow10_helper",
":strings",
"//absl/base:config",
diff --git a/absl/strings/CMakeLists.txt b/absl/strings/CMakeLists.txt
index 668d722b..c7874ecf 100644
--- a/absl/strings/CMakeLists.txt
+++ b/absl/strings/CMakeLists.txt
@@ -284,6 +284,7 @@ absl_cc_test(
absl::raw_logging_internal
absl::random_random
absl::random_distributions
+ absl::strings_internal
gmock_main
)
diff --git a/absl/strings/internal/str_format/arg.cc b/absl/strings/internal/str_format/arg.cc
index 4d0604e0..3aa0296b 100644
--- a/absl/strings/internal/str_format/arg.cc
+++ b/absl/strings/internal/str_format/arg.cc
@@ -120,24 +120,25 @@ class ConvertedIntInfo {
// the '#' flag is specified to modify the precision for 'o' conversions.
string_view BaseIndicator(const ConvertedIntInfo &info,
const ConversionSpec conv) {
- bool alt = conv.flags().alt;
- int radix = FormatConversionCharRadix(conv.conv());
- if (conv.conv() == ConversionChar::p) alt = true; // always show 0x for %p.
+ bool alt = conv.has_alt_flag();
+ int radix = FormatConversionCharRadix(conv.conversion_char());
+ if (conv.conversion_char() == ConversionChar::p)
+ alt = true; // always show 0x for %p.
// From the POSIX description of '#' flag:
// "For x or X conversion specifiers, a non-zero result shall have
// 0x (or 0X) prefixed to it."
if (alt && radix == 16 && !info.digits().empty()) {
- if (FormatConversionCharIsUpper(conv.conv())) return "0X";
+ if (FormatConversionCharIsUpper(conv.conversion_char())) return "0X";
return "0x";
}
return {};
}
string_view SignColumn(bool neg, const ConversionSpec conv) {
- if (FormatConversionCharIsSigned(conv.conv())) {
+ if (FormatConversionCharIsSigned(conv.conversion_char())) {
if (neg) return "-";
- if (conv.flags().show_pos) return "+";
- if (conv.flags().sign_col) return " ";
+ if (conv.has_show_pos_flag()) return "+";
+ if (conv.has_sign_col_flag()) return " ";
}
return {};
}
@@ -147,9 +148,9 @@ bool ConvertCharImpl(unsigned char v, const ConversionSpec conv,
size_t fill = 0;
if (conv.width() >= 0) fill = conv.width();
ReducePadding(1, &fill);
- if (!conv.flags().left) sink->Append(fill, ' ');
+ if (!conv.has_left_flag()) sink->Append(fill, ' ');
sink->Append(1, v);
- if (conv.flags().left) sink->Append(fill, ' ');
+ if (conv.has_left_flag()) sink->Append(fill, ' ');
return true;
}
@@ -174,7 +175,7 @@ bool ConvertIntImplInner(const ConvertedIntInfo &info,
if (!precision_specified)
precision = 1;
- if (conv.flags().alt && conv.conv() == ConversionChar::o) {
+ if (conv.has_alt_flag() && conv.conversion_char() == ConversionChar::o) {
// From POSIX description of the '#' (alt) flag:
// "For o conversion, it increases the precision (if necessary) to
// force the first digit of the result to be zero."
@@ -187,13 +188,13 @@ bool ConvertIntImplInner(const ConvertedIntInfo &info,
size_t num_zeroes = Excess(formatted.size(), precision);
ReducePadding(num_zeroes, &fill);
- size_t num_left_spaces = !conv.flags().left ? fill : 0;
- size_t num_right_spaces = conv.flags().left ? fill : 0;
+ size_t num_left_spaces = !conv.has_left_flag() ? fill : 0;
+ size_t num_right_spaces = conv.has_left_flag() ? fill : 0;
// From POSIX description of the '0' (zero) flag:
// "For d, i, o, u, x, and X conversion specifiers, if a precision
// is specified, the '0' flag is ignored."
- if (!precision_specified && conv.flags().zero) {
+ if (!precision_specified && conv.has_zero_flag()) {
num_zeroes += num_left_spaces;
num_left_spaces = 0;
}
@@ -209,8 +210,8 @@ bool ConvertIntImplInner(const ConvertedIntInfo &info,
template <typename T>
bool ConvertIntImplInner(T v, const ConversionSpec conv, FormatSinkImpl *sink) {
- ConvertedIntInfo info(v, conv.conv());
- if (conv.flags().basic && (conv.conv() != ConversionChar::p)) {
+ ConvertedIntInfo info(v, conv.conversion_char());
+ if (conv.is_basic() && (conv.conversion_char() != ConversionChar::p)) {
if (info.is_neg()) sink->Append(1, '-');
if (info.digits().empty()) {
sink->Append(1, '0');
@@ -224,13 +225,14 @@ bool ConvertIntImplInner(T v, const ConversionSpec conv, FormatSinkImpl *sink) {
template <typename T>
bool ConvertIntArg(T v, const ConversionSpec conv, FormatSinkImpl *sink) {
- if (FormatConversionCharIsFloat(conv.conv())) {
+ if (FormatConversionCharIsFloat(conv.conversion_char())) {
return FormatConvertImpl(static_cast<double>(v), conv, sink).value;
}
- if (conv.conv() == ConversionChar::c)
+ if (conv.conversion_char() == ConversionChar::c)
return ConvertCharImpl(static_cast<unsigned char>(v), conv, sink);
- if (!FormatConversionCharIsIntegral(conv.conv())) return false;
- if (!FormatConversionCharIsSigned(conv.conv()) && IsSigned<T>::value) {
+ if (!FormatConversionCharIsIntegral(conv.conversion_char())) return false;
+ if (!FormatConversionCharIsSigned(conv.conversion_char()) &&
+ IsSigned<T>::value) {
using U = typename MakeUnsigned<T>::type;
return FormatConvertImpl(static_cast<U>(v), conv, sink).value;
}
@@ -239,19 +241,19 @@ bool ConvertIntArg(T v, const ConversionSpec conv, FormatSinkImpl *sink) {
template <typename T>
bool ConvertFloatArg(T v, const ConversionSpec conv, FormatSinkImpl *sink) {
- return FormatConversionCharIsFloat(conv.conv()) &&
+ return FormatConversionCharIsFloat(conv.conversion_char()) &&
ConvertFloatImpl(v, conv, sink);
}
inline bool ConvertStringArg(string_view v, const ConversionSpec conv,
FormatSinkImpl *sink) {
- if (conv.conv() != ConversionChar::s) return false;
- if (conv.flags().basic) {
+ if (conv.conversion_char() != ConversionChar::s) return false;
+ if (conv.is_basic()) {
sink->Append(v);
return true;
}
return sink->PutPaddedString(v, conv.width(), conv.precision(),
- conv.flags().left);
+ conv.has_left_flag());
}
} // namespace
@@ -272,7 +274,7 @@ ConvertResult<Conv::s> FormatConvertImpl(string_view v,
ConvertResult<Conv::s | Conv::p> FormatConvertImpl(const char *v,
const ConversionSpec conv,
FormatSinkImpl *sink) {
- if (conv.conv() == ConversionChar::p)
+ if (conv.conversion_char() == ConversionChar::p)
return {FormatConvertImpl(VoidPtr(v), conv, sink).value};
size_t len;
if (v == nullptr) {
@@ -289,7 +291,7 @@ ConvertResult<Conv::s | Conv::p> FormatConvertImpl(const char *v,
// ==================== Raw pointers ====================
ConvertResult<Conv::p> FormatConvertImpl(VoidPtr v, const ConversionSpec conv,
FormatSinkImpl *sink) {
- if (conv.conv() != ConversionChar::p) return {false};
+ if (conv.conversion_char() != ConversionChar::p) return {false};
if (!v.value) {
sink->Append("(nil)");
return {true};
diff --git a/absl/strings/internal/str_format/arg.h b/absl/strings/internal/str_format/arg.h
index 7a937563..1c36e309 100644
--- a/absl/strings/internal/str_format/arg.h
+++ b/absl/strings/internal/str_format/arg.h
@@ -70,9 +70,11 @@ template <class AbslCord,
ConvertResult<Conv::s> FormatConvertImpl(const AbslCord& value,
ConversionSpec conv,
FormatSinkImpl* sink) {
- if (conv.conv() != ConversionChar::s) return {false};
+ if (conv.conversion_char() != ConversionChar::s) {
+ return {false};
+ }
- bool is_left = conv.flags().left;
+ bool is_left = conv.has_left_flag();
size_t space_remaining = 0;
int width = conv.width();
@@ -106,8 +108,8 @@ ConvertResult<Conv::s> FormatConvertImpl(const AbslCord& value,
}
using IntegralConvertResult =
- ConvertResult<Conv::c | Conv::numeric | Conv::star>;
-using FloatingConvertResult = ConvertResult<Conv::floating>;
+ ConvertResult<Conv::c | Conv::kNumeric | Conv::kStar>;
+using FloatingConvertResult = ConvertResult<Conv::kFloating>;
// Floats.
FloatingConvertResult FormatConvertImpl(float v, ConversionSpec conv,
@@ -185,7 +187,9 @@ struct FormatCountCaptureHelper {
FormatSinkImpl* sink) {
const absl::enable_if_t<sizeof(T) != 0, FormatCountCapture>& v2 = v;
- if (conv.conv() != str_format_internal::ConversionChar::n) return {false};
+ if (conv.conversion_char() != str_format_internal::ConversionChar::n) {
+ return {false};
+ }
*v2.p_ = static_cast<int>(sink->size());
return {true};
}
@@ -377,7 +381,7 @@ class FormatArgImpl {
template <typename T>
static bool Dispatch(Data arg, ConversionSpec spec, void* out) {
// A `none` conv indicates that we want the `int` conversion.
- if (ABSL_PREDICT_FALSE(spec.conv() == ConversionChar::none)) {
+ if (ABSL_PREDICT_FALSE(spec.conversion_char() == ConversionChar::kNone)) {
return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
std::is_enum<T>());
}
diff --git a/absl/strings/internal/str_format/bind.cc b/absl/strings/internal/str_format/bind.cc
index 27522fdb..6980ed1d 100644
--- a/absl/strings/internal/str_format/bind.cc
+++ b/absl/strings/internal/str_format/bind.cc
@@ -147,7 +147,7 @@ class SummarizingConverter {
<< FormatConversionSpecImplFriend::FlagsToString(bound);
if (bound.width() >= 0) ss << bound.width();
if (bound.precision() >= 0) ss << "." << bound.precision();
- ss << bound.conv() << "}";
+ ss << bound.conversion_char() << "}";
Append(ss.str());
return true;
}
diff --git a/absl/strings/internal/str_format/checker_test.cc b/absl/strings/internal/str_format/checker_test.cc
index ea2a7681..49a24b40 100644
--- a/absl/strings/internal/str_format/checker_test.cc
+++ b/absl/strings/internal/str_format/checker_test.cc
@@ -9,13 +9,17 @@ ABSL_NAMESPACE_BEGIN
namespace str_format_internal {
namespace {
-std::string ConvToString(Conv conv) {
+std::string ConvToString(FormatConversionCharSet conv) {
std::string out;
#define CONV_SET_CASE(c) \
- if (Contains(conv, Conv::c)) out += #c;
+ if (Contains(conv, FormatConversionCharSet::c)) { \
+ out += #c; \
+ }
ABSL_INTERNAL_CONVERSION_CHARS_EXPAND_(CONV_SET_CASE, )
#undef CONV_SET_CASE
- if (Contains(conv, Conv::star)) out += "*";
+ if (Contains(conv, FormatConversionCharSet::kStar)) {
+ out += "*";
+ }
return out;
}
diff --git a/absl/strings/internal/str_format/float_conversion.cc b/absl/strings/internal/str_format/float_conversion.cc
index d4c647c3..d5a1ee40 100644
--- a/absl/strings/internal/str_format/float_conversion.cc
+++ b/absl/strings/internal/str_format/float_conversion.cc
@@ -33,7 +33,7 @@ bool FallbackToSnprintf(const Float v, const ConversionSpec &conv,
if (std::is_same<long double, Float>()) {
*fp++ = 'L';
}
- *fp++ = FormatConversionCharToChar(conv.conv());
+ *fp++ = FormatConversionCharToChar(conv.conversion_char());
*fp = 0;
assert(fp < fmt + sizeof(fmt));
}
@@ -100,17 +100,19 @@ bool ConvertNonNumericFloats(char sign_char, Float v,
char text[4], *ptr = text;
if (sign_char) *ptr++ = sign_char;
if (std::isnan(v)) {
- ptr = std::copy_n(FormatConversionCharIsUpper(conv.conv()) ? "NAN" : "nan",
- 3, ptr);
+ ptr = std::copy_n(
+ FormatConversionCharIsUpper(conv.conversion_char()) ? "NAN" : "nan", 3,
+ ptr);
} else if (std::isinf(v)) {
- ptr = std::copy_n(FormatConversionCharIsUpper(conv.conv()) ? "INF" : "inf",
- 3, ptr);
+ ptr = std::copy_n(
+ FormatConversionCharIsUpper(conv.conversion_char()) ? "INF" : "inf", 3,
+ ptr);
} else {
return false;
}
return sink->PutPaddedString(string_view(text, ptr - text), conv.width(), -1,
- conv.flags().left);
+ conv.has_left_flag());
}
// Round up the last digit of the value.
@@ -358,9 +360,9 @@ void WriteBufferToSink(char sign_char, string_view str,
static_cast<int>(sign_char != 0),
0)
: 0;
- if (conv.flags().left) {
+ if (conv.has_left_flag()) {
right_spaces = missing_chars;
- } else if (conv.flags().zero) {
+ } else if (conv.has_zero_flag()) {
zeros = missing_chars;
} else {
left_spaces = missing_chars;
@@ -382,9 +384,9 @@ bool FloatToSink(const Float v, const ConversionSpec &conv,
if (std::signbit(abs_v)) {
sign_char = '-';
abs_v = -abs_v;
- } else if (conv.flags().show_pos) {
+ } else if (conv.has_show_pos_flag()) {
sign_char = '+';
- } else if (conv.flags().sign_col) {
+ } else if (conv.has_sign_col_flag()) {
sign_char = ' ';
}
@@ -401,14 +403,14 @@ bool FloatToSink(const Float v, const ConversionSpec &conv,
Buffer buffer;
- switch (conv.conv()) {
+ switch (conv.conversion_char()) {
case ConversionChar::f:
case ConversionChar::F:
if (!FloatToBuffer<FormatStyle::Fixed>(decomposed, precision, &buffer,
nullptr)) {
return FallbackToSnprintf(v, conv, sink);
}
- if (!conv.flags().alt && buffer.back() == '.') buffer.pop_back();
+ if (!conv.has_alt_flag() && buffer.back() == '.') buffer.pop_back();
break;
case ConversionChar::e:
@@ -417,9 +419,10 @@ bool FloatToSink(const Float v, const ConversionSpec &conv,
&exp)) {
return FallbackToSnprintf(v, conv, sink);
}
- if (!conv.flags().alt && buffer.back() == '.') buffer.pop_back();
- PrintExponent(exp, FormatConversionCharIsUpper(conv.conv()) ? 'E' : 'e',
- &buffer);
+ if (!conv.has_alt_flag() && buffer.back() == '.') buffer.pop_back();
+ PrintExponent(
+ exp, FormatConversionCharIsUpper(conv.conversion_char()) ? 'E' : 'e',
+ &buffer);
break;
case ConversionChar::g:
@@ -446,13 +449,15 @@ bool FloatToSink(const Float v, const ConversionSpec &conv,
}
exp = 0;
}
- if (!conv.flags().alt) {
+ if (!conv.has_alt_flag()) {
while (buffer.back() == '0') buffer.pop_back();
if (buffer.back() == '.') buffer.pop_back();
}
if (exp) {
- PrintExponent(exp, FormatConversionCharIsUpper(conv.conv()) ? 'E' : 'e',
- &buffer);
+ PrintExponent(
+ exp,
+ FormatConversionCharIsUpper(conv.conversion_char()) ? 'E' : 'e',
+ &buffer);
}
break;
diff --git a/absl/strings/internal/str_format/parser_test.cc b/absl/strings/internal/str_format/parser_test.cc
index 1b1ee030..51eb53f5 100644
--- a/absl/strings/internal/str_format/parser_test.cc
+++ b/absl/strings/internal/str_format/parser_test.cc
@@ -52,7 +52,7 @@ TEST(ConversionCharTest, Names) {
X(f), X(F), X(e), X(E), X(g), X(G), X(a), X(A), // float
X(n), X(p), // misc
#undef X
- {ConversionChar::none, '\0'},
+ {ConversionChar::kNone, '\0'},
};
// clang-format on
for (auto e : kExpect) {
diff --git a/absl/strings/numbers_test.cc b/absl/strings/numbers_test.cc
index bd4e1162..7db85e75 100644
--- a/absl/strings/numbers_test.cc
+++ b/absl/strings/numbers_test.cc
@@ -40,6 +40,7 @@
#include "absl/random/distributions.h"
#include "absl/random/random.h"
#include "absl/strings/internal/numbers_test_common.h"
+#include "absl/strings/internal/ostringstream.h"
#include "absl/strings/internal/pow10_helper.h"
#include "absl/strings/str_cat.h"
diff --git a/absl/strings/str_format_test.cc b/absl/strings/str_format_test.cc
index 554dca72..f0d1f0ad 100644
--- a/absl/strings/str_format_test.cc
+++ b/absl/strings/str_format_test.cc
@@ -540,19 +540,19 @@ TEST_F(ParsedFormatTest, UncheckedCorrect) {
EXPECT_EQ("[ABC]{d:1$d}[DEF]", SummarizeParsedFormat(*f));
std::string format = "%sFFF%dZZZ%f";
- auto f2 =
- ExtendedParsedFormat<Conv::string, Conv::d, Conv::floating>::New(format);
+ auto f2 = ExtendedParsedFormat<Conv::kString, Conv::d, Conv::kFloating>::New(
+ format);
ASSERT_TRUE(f2);
EXPECT_EQ("{s:1$s}[FFF]{d:2$d}[ZZZ]{f:3$f}", SummarizeParsedFormat(*f2));
- f2 = ExtendedParsedFormat<Conv::string, Conv::d, Conv::floating>::New(
+ f2 = ExtendedParsedFormat<Conv::kString, Conv::d, Conv::kFloating>::New(
"%s %d %f");
ASSERT_TRUE(f2);
EXPECT_EQ("{s:1$s}[ ]{d:2$d}[ ]{f:3$f}", SummarizeParsedFormat(*f2));
- auto star = ExtendedParsedFormat<Conv::star, Conv::d>::New("%*d");
+ auto star = ExtendedParsedFormat<Conv::kStar, Conv::d>::New("%*d");
ASSERT_TRUE(star);
EXPECT_EQ("{*d:2$1$*d}", SummarizeParsedFormat(*star));