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

Export of internal Abseil changes

Browse source 
--
1bc4d36e13fb9175ea8cdaa00213aa9d4417c669 by Andy Getzendanner <durandal@google.com>:

Fix pointer format specifier in documentation

Import of https://github.com/abseil/abseil-cpp/pull/614

PiperOrigin-RevId: 293227540

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

Internal change.

PiperOrigin-RevId: 293160245

--
64439365e2b4a0b5e51ae0a7dafdb15912402dfd by Shahriar Rouf <nafi@google.com>:

Add benchmarks for string_view: BM_CompareFirstOneLess and BM_CompareSecondOneLess.

PiperOrigin-RevId: 293031676

--
b273b420cab24a6e3f487430987e09f4eb1caec4 by Greg Falcon <gfalcon@google.com>:

Remove an unreachable line from charconv.cc.

Fixes github issue #613.

PiperOrigin-RevId: 292980167

--
70babb5f7a3d9fdd00a2b3085c3c2b9fe0265c79 by Gennadiy Rozental <rogeeff@google.com>:

Move GetFlag implementation into FlagImpl.

This change will allow us to hide details of GetFlag overloads inside implementation detais. Eventually we'll migrate to a different implementation. No semantic changes in this CL.

PiperOrigin-RevId: 292930847

--
94bee7b7cc31e0167ee4b953281c1e78c96a574a by Abseil Team <absl-team@google.com>:

Clarification in absl::Exponential documentation.

PiperOrigin-RevId: 292912672

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

Make AtomicHook constant-initializable on Clang for Windows.

Only mark AtomicHook as constant-initializable on platforms where it
is actually constant-initializable.

PiperOrigin-RevId: 292655939
GitOrigin-RevId: 1bc4d36e13fb9175ea8cdaa00213aa9d4417c669
Change-Id: I090b231a0ca0d92868e494ab5b3fa86c902889d5
This commit is contained in:
Abseil Team 2020-02-04 14:18:00 -08:00 • committed by Andy Getz
parent 36bcd9599b
commit 08a7e7bf97
15 changed files with 315 additions and 228 deletions
Download patch file Download diff file Expand all files Collapse all files

33
absl/flags/flag.h
View file

@ -186,15 +186,17 @@ class Flag {
//
// // FLAGS_firstname is a Flag of type `std::string`
// std::string first_name = absl::GetFlag(FLAGS_firstname);
template <typename T>
ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag) {
return flag.Get();
}
#ifndef NDEBUG
// We want to validate the type mismatch between type definition and
// declaration. The lock-free implementation does not allow us to do it,
// so in debug builds we always use the slower implementation, which always
// validates the type.
template <typename T>
ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag) {
return flag.Get();
}
// We currently need an external linkage for built-in types because shared
// libraries have different addresses of flags_internal::FlagOps<T> which
// might cause log spam when checking the same flag type.
@ -202,29 +204,6 @@ ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag) {
ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag);
ABSL_FLAGS_INTERNAL_BUILTIN_TYPES(ABSL_FLAGS_INTERNAL_BUILT_IN_EXPORT)
#undef ABSL_FLAGS_INTERNAL_BUILT_IN_EXPORT
#else
template <typename T,
typename std::enable_if<
!flags_internal::IsAtomicFlagTypeTrait<T>::value, int>::type = 0>
ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag) {
return flag.Get();
}
// Overload for `GetFlag()` for types that support lock-free reads.
template <typename T,
typename std::enable_if<
flags_internal::IsAtomicFlagTypeTrait<T>::value, int>::type = 0>
ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag<T>& flag) {
// T might not be default constructible.
union U {
T value;
U() {}
};
U result;
if (flag.AtomicGet(&result.value)) {
return result.value;
}
return flag.Get();
}
#endif
// SetFlag()

28
absl/flags/internal/flag.h
View file

@ -244,16 +244,32 @@ class FlagImpl {
bool TryParse(void** dst, absl::string_view value, std::string* err) const
ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
#ifndef NDEBUG
template <typename T>
bool AtomicGet(T* v) const {
void Get(T* dst) const {
Read(dst, &flags_internal::FlagOps<T>);
}
#else
template <typename T, typename std::enable_if<
!flags_internal::IsAtomicFlagTypeTrait<T>::value,
int>::type = 0>
void Get(T* dst) const {
Read(dst, &flags_internal::FlagOps<T>);
}
// Overload for `GetFlag()` for types that support lock-free reads.
template <typename T,
typename std::enable_if<
flags_internal::IsAtomicFlagTypeTrait<T>::value, int>::type = 0>
void Get(T* dst) const {
using U = flags_internal::BestAtomicType<T>;
const typename U::type r = atomics_.template load<T>();
if (r != U::AtomicInit()) {
std::memcpy(static_cast<void*>(v), &r, sizeof(T));
return true;
std::memcpy(static_cast<void*>(dst), &r, sizeof(T));
} else {
Read(dst, &flags_internal::FlagOps<T>);
}
return false;
}
#endif
// Mutating access methods
void Write(const void* src, const flags_internal::FlagOpFn src_op)
@ -397,12 +413,10 @@ class Flag final : public flags_internal::CommandLineFlag {
};
U u;
impl_.Read(&u.value, &flags_internal::FlagOps<T>);
impl_.Get(&u.value);
return std::move(u.value);
}
bool AtomicGet(T* v) const { return impl_.AtomicGet(v); }
void Set(const T& v) { impl_.Write(&v, &flags_internal::FlagOps<T>); }
void SetCallback(const flags_internal::FlagCallback mutation_callback) {