summaryrefslogtreecommitdiff
path: root/absl/flags
diff options
context:
space:
mode:
Diffstat (limited to 'absl/flags')
-rw-r--r--absl/flags/flag.h8
-rw-r--r--absl/flags/internal/flag.cc71
-rw-r--r--absl/flags/internal/flag.h91
3 files changed, 103 insertions, 67 deletions
diff --git a/absl/flags/flag.h b/absl/flags/flag.h
index 09af47a0..52c3cede 100644
--- a/absl/flags/flag.h
+++ b/absl/flags/flag.h
@@ -96,12 +96,12 @@ class Flag {
constexpr Flag(const char* name, const flags_internal::HelpGenFunc help_gen,
const char* filename,
const flags_internal::FlagMarshallingOpFn marshalling_op,
- const flags_internal::InitialValGenFunc initial_value_gen)
+ const flags_internal::FlagDfltGenFunc default_value_gen)
: name_(name),
help_gen_(help_gen),
filename_(filename),
marshalling_op_(marshalling_op),
- initial_value_gen_(initial_value_gen),
+ default_value_gen_(default_value_gen),
inited_(false),
impl_(nullptr) {}
#endif
@@ -118,7 +118,7 @@ class Flag {
name_,
{flags_internal::FlagHelpSrc(help_gen_),
flags_internal::FlagHelpSrcKind::kGenFunc},
- filename_, marshalling_op_, initial_value_gen_);
+ filename_, marshalling_op_, default_value_gen_);
inited_.store(true, std::memory_order_release);
}
@@ -157,7 +157,7 @@ class Flag {
const flags_internal::HelpGenFunc help_gen_;
const char* filename_;
const flags_internal::FlagMarshallingOpFn marshalling_op_;
- const flags_internal::InitialValGenFunc initial_value_gen_;
+ const flags_internal::FlagDfltGenFunc default_value_gen_;
mutable std::atomic<bool> inited_;
mutable flags_internal::Flag<T>* impl_;
diff --git a/absl/flags/internal/flag.cc b/absl/flags/internal/flag.cc
index d087f79e..435cc362 100644
--- a/absl/flags/internal/flag.cc
+++ b/absl/flags/internal/flag.cc
@@ -49,12 +49,11 @@ void FlagImpl::Init() {
absl::MutexLock lock(&locks_->primary_mu);
- if (def_ != nullptr) {
+ if (cur_ != nullptr) {
inited_.store(true, std::memory_order_release);
} else {
- // Need to initialize def and cur fields.
- def_ = (*initial_value_gen_)();
- cur_ = Clone(op_, def_);
+ // Need to initialize cur field.
+ cur_ = MakeInitValue().release();
StoreAtomic();
inited_.store(true, std::memory_order_release);
InvokeCallback();
@@ -63,8 +62,7 @@ void FlagImpl::Init() {
// Ensures that the lazily initialized data is initialized,
// and returns pointer to the mutex guarding flags data.
-absl::Mutex* FlagImpl::DataGuard() const
- ABSL_LOCK_RETURNED(locks_->primary_mu) {
+absl::Mutex* FlagImpl::DataGuard() const {
if (ABSL_PREDICT_FALSE(!inited_.load(std::memory_order_acquire))) {
const_cast<FlagImpl*>(this)->Init();
}
@@ -79,12 +77,23 @@ void FlagImpl::Destroy() const {
// Values are heap allocated for Abseil Flags.
if (cur_) Delete(op_, cur_);
- if (def_) Delete(op_, def_);
+ if (def_kind_ == FlagDefaultSrcKind::kDynamicValue)
+ Delete(op_, default_src_.dynamic_value);
}
delete locks_;
}
+std::unique_ptr<void, DynValueDeleter> FlagImpl::MakeInitValue() const {
+ void* res = nullptr;
+ if (def_kind_ == FlagDefaultSrcKind::kDynamicValue) {
+ res = Clone(op_, default_src_.dynamic_value);
+ } else {
+ res = (*default_src_.gen_func)();
+ }
+ return {res, DynValueDeleter{op_}};
+}
+
std::string FlagImpl::Help() const {
return help_source_kind_ == FlagHelpSrcKind::kLiteral ? help_.literal
: help_.gen_func();
@@ -103,7 +112,8 @@ bool FlagImpl::IsSpecifiedOnCommandLine() const {
std::string FlagImpl::DefaultValue() const {
absl::MutexLock l(DataGuard());
- return Unparse(marshalling_op_, def_);
+ auto obj = MakeInitValue();
+ return Unparse(marshalling_op_, obj.get());
}
std::string FlagImpl::CurrentValue() const {
@@ -121,8 +131,7 @@ void FlagImpl::SetCallback(
InvokeCallback();
}
-void FlagImpl::InvokeCallback() const
- ABSL_EXCLUSIVE_LOCKS_REQUIRED(locks_->primary_mu) {
+void FlagImpl::InvokeCallback() const {
if (!callback_) return;
// If the flag has a mutation callback this function invokes it. While the
@@ -172,23 +181,20 @@ bool FlagImpl::RestoreState(const CommandLineFlag& flag, const void* value,
// 'dst' assuming it is a pointer to the flag's value type. In case if any error
// is encountered in either step, the error message is stored in 'err'
bool FlagImpl::TryParse(const CommandLineFlag& flag, void* dst,
- absl::string_view value, std::string* err) const
- ABSL_EXCLUSIVE_LOCKS_REQUIRED(locks_->primary_mu) {
- void* tentative_value = Clone(op_, def_);
+ absl::string_view value, std::string* err) const {
+ auto tentative_value = MakeInitValue();
std::string parse_err;
- if (!Parse(marshalling_op_, value, tentative_value, &parse_err)) {
+ if (!Parse(marshalling_op_, value, tentative_value.get(), &parse_err)) {
auto type_name = flag.Typename();
absl::string_view err_sep = parse_err.empty() ? "" : "; ";
absl::string_view typename_sep = type_name.empty() ? "" : " ";
*err = absl::StrCat("Illegal value '", value, "' specified for",
typename_sep, type_name, " flag '", flag.Name(), "'",
err_sep, parse_err);
- Delete(op_, tentative_value);
return false;
}
- Copy(op_, tentative_value, dst);
- Delete(op_, tentative_value);
+ Copy(op_, tentative_value.get(), dst);
return true;
}
@@ -208,7 +214,7 @@ void FlagImpl::Read(const CommandLineFlag& flag, void* dst,
CopyConstruct(op_, cur_, dst);
}
-void FlagImpl::StoreAtomic() ABSL_EXCLUSIVE_LOCKS_REQUIRED(locks_->primary_mu) {
+void FlagImpl::StoreAtomic() {
size_t data_size = Sizeof(op_);
if (data_size <= sizeof(int64_t)) {
@@ -299,12 +305,22 @@ bool FlagImpl::SetFromString(const CommandLineFlag& flag,
break;
}
case SET_FLAGS_DEFAULT: {
- // modify the flag's default-value
- if (!TryParse(flag, def_, value, err)) return false;
+ // Flag's new default-value.
+ auto new_default_value = MakeInitValue();
+
+ if (!TryParse(flag, new_default_value.get(), value, err)) return false;
+
+ if (def_kind_ == FlagDefaultSrcKind::kDynamicValue) {
+ // Release old default value.
+ Delete(op_, default_src_.dynamic_value);
+ }
+
+ default_src_.dynamic_value = new_default_value.release();
+ def_kind_ = FlagDefaultSrcKind::kDynamicValue;
if (!modified_) {
// Need to set both default value *and* current, in this case
- Copy(op_, def_, cur_);
+ Copy(op_, default_src_.dynamic_value, cur_);
StoreAtomic();
InvokeCallback();
}
@@ -321,9 +337,9 @@ void FlagImpl::CheckDefaultValueParsingRoundtrip(
absl::MutexLock lock(DataGuard());
- void* dst = Clone(op_, def_);
+ auto dst = MakeInitValue();
std::string error;
- if (!flags_internal::Parse(marshalling_op_, v, dst, &error)) {
+ if (!flags_internal::Parse(marshalling_op_, v, dst.get(), &error)) {
ABSL_INTERNAL_LOG(
FATAL,
absl::StrCat("Flag ", flag.Name(), " (from ", flag.Filename(),
@@ -333,18 +349,15 @@ void FlagImpl::CheckDefaultValueParsingRoundtrip(
// We do not compare dst to def since parsing/unparsing may make
// small changes, e.g., precision loss for floating point types.
- Delete(op_, dst);
}
bool FlagImpl::ValidateInputValue(absl::string_view value) const {
absl::MutexLock l(DataGuard());
- void* obj = Clone(op_, def_);
+ auto obj = MakeInitValue();
std::string ignored_error;
- const bool result =
- flags_internal::Parse(marshalling_op_, value, obj, &ignored_error);
- Delete(op_, obj);
- return result;
+ return flags_internal::Parse(marshalling_op_, value, obj.get(),
+ &ignored_error);
}
} // namespace flags_internal
diff --git a/absl/flags/internal/flag.h b/absl/flags/internal/flag.h
index d7990254..947a8cad 100644
--- a/absl/flags/internal/flag.h
+++ b/absl/flags/internal/flag.h
@@ -119,47 +119,61 @@ constexpr flags_internal::HelpInitArg HelpArg(char) {
flags_internal::FlagHelpSrcKind::kGenFunc};
}
-// Signature for the function generating the initial flag value based (usually
+// Signature for the function generating the initial flag value (usually
// based on default value supplied in flag's definition)
-using InitialValGenFunc = void* (*)();
+using FlagDfltGenFunc = void* (*)();
+
+union FlagDefaultSrc {
+ constexpr explicit FlagDefaultSrc(FlagDfltGenFunc gen_func_arg)
+ : gen_func(gen_func_arg) {}
+
+ void* dynamic_value;
+ FlagDfltGenFunc gen_func;
+};
+
+enum class FlagDefaultSrcKind : int8_t { kDynamicValue, kGenFunc };
// Signature for the mutation callback used by watched Flags
// The callback is noexcept.
// TODO(rogeeff): add noexcept after C++17 support is added.
using FlagCallback = void (*)();
-void InvokeCallback(absl::Mutex* primary_mu, absl::Mutex* callback_mu,
- FlagCallback cb) ABSL_EXCLUSIVE_LOCKS_REQUIRED(primary_mu);
+struct DynValueDeleter {
+ void operator()(void* ptr) const { Delete(op, ptr); }
+
+ const FlagOpFn op;
+};
// The class encapsulates the Flag's data and safe access to it.
class FlagImpl {
public:
constexpr FlagImpl(const flags_internal::FlagOpFn op,
const flags_internal::FlagMarshallingOpFn marshalling_op,
- const flags_internal::InitialValGenFunc initial_value_gen,
+ const flags_internal::FlagDfltGenFunc default_value_gen,
const HelpInitArg help)
: op_(op),
marshalling_op_(marshalling_op),
- initial_value_gen_(initial_value_gen),
help_(help.source),
- help_source_kind_(help.kind) {}
+ help_source_kind_(help.kind),
+ def_kind_(flags_internal::FlagDefaultSrcKind::kGenFunc),
+ default_src_(default_value_gen) {}
// Forces destruction of the Flag's data.
void Destroy() const;
// Constant access methods
std::string Help() const;
- bool IsModified() const ABSL_LOCKS_EXCLUDED(locks_->primary_mu);
- bool IsSpecifiedOnCommandLine() const ABSL_LOCKS_EXCLUDED(locks_->primary_mu);
- std::string DefaultValue() const ABSL_LOCKS_EXCLUDED(locks_->primary_mu);
- std::string CurrentValue() const ABSL_LOCKS_EXCLUDED(locks_->primary_mu);
+ bool IsModified() const ABSL_LOCKS_EXCLUDED(*DataGuard());
+ bool IsSpecifiedOnCommandLine() const ABSL_LOCKS_EXCLUDED(*DataGuard());
+ std::string DefaultValue() const ABSL_LOCKS_EXCLUDED(*DataGuard());
+ std::string CurrentValue() const ABSL_LOCKS_EXCLUDED(*DataGuard());
void Read(const CommandLineFlag& flag, void* dst,
const flags_internal::FlagOpFn dst_op) const
- ABSL_LOCKS_EXCLUDED(locks_->primary_mu);
+ ABSL_LOCKS_EXCLUDED(*DataGuard());
// Attempts to parse supplied `value` std::string.
bool TryParse(const CommandLineFlag& flag, void* dst, absl::string_view value,
std::string* err) const
- ABSL_EXCLUSIVE_LOCKS_REQUIRED(locks_->primary_mu);
+ ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
template <typename T>
bool AtomicGet(T* v) const {
const int64_t r = atomic_.load(std::memory_order_acquire);
@@ -174,23 +188,23 @@ class FlagImpl {
// Mutating access methods
void Write(const CommandLineFlag& flag, const void* src,
const flags_internal::FlagOpFn src_op)
- ABSL_LOCKS_EXCLUDED(locks_->primary_mu);
+ ABSL_LOCKS_EXCLUDED(*DataGuard());
bool SetFromString(const CommandLineFlag& flag, absl::string_view value,
FlagSettingMode set_mode, ValueSource source,
- std::string* err) ABSL_LOCKS_EXCLUDED(locks_->primary_mu);
+ std::string* err) ABSL_LOCKS_EXCLUDED(*DataGuard());
// If possible, updates copy of the Flag's value that is stored in an
// atomic word.
- void StoreAtomic() ABSL_EXCLUSIVE_LOCKS_REQUIRED(locks_->primary_mu);
+ void StoreAtomic() ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
// Interfaces to operate on callbacks.
void SetCallback(const flags_internal::FlagCallback mutation_callback)
- ABSL_LOCKS_EXCLUDED(locks_->primary_mu);
- void InvokeCallback() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(locks_->primary_mu);
+ ABSL_LOCKS_EXCLUDED(*DataGuard());
+ void InvokeCallback() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
// Interfaces to save/restore mutable flag data
template <typename T>
std::unique_ptr<flags_internal::FlagStateInterface> SaveState(
- Flag<T>* flag) const ABSL_LOCKS_EXCLUDED(locks_->primary_mu) {
+ Flag<T>* flag) const ABSL_LOCKS_EXCLUDED(*DataGuard()) {
T&& cur_value = flag->Get();
absl::MutexLock l(DataGuard());
@@ -199,13 +213,13 @@ class FlagImpl {
}
bool RestoreState(const CommandLineFlag& flag, const void* value,
bool modified, bool on_command_line, int64_t counter)
- ABSL_LOCKS_EXCLUDED(locks_->primary_mu);
+ ABSL_LOCKS_EXCLUDED(*DataGuard());
// Value validation interfaces.
void CheckDefaultValueParsingRoundtrip(const CommandLineFlag& flag) const
- ABSL_LOCKS_EXCLUDED(locks_->primary_mu);
+ ABSL_LOCKS_EXCLUDED(*DataGuard());
bool ValidateInputValue(absl::string_view value) const
- ABSL_LOCKS_EXCLUDED(locks_->primary_mu);
+ ABSL_LOCKS_EXCLUDED(*DataGuard());
private:
// Lazy initialization of the Flag's data.
@@ -214,27 +228,36 @@ class FlagImpl {
// and returns pointer to the mutex guarding flags data.
absl::Mutex* DataGuard() const ABSL_LOCK_RETURNED(locks_->primary_mu);
+ // Returns heap allocated value of type T initialized with default value.
+ std::unique_ptr<void, DynValueDeleter> MakeInitValue() const
+ ABSL_EXCLUSIVE_LOCKS_REQUIRED(*DataGuard());
+
// Immutable Flag's data.
- const FlagOpFn op_; // Type-specific handler.
- const FlagMarshallingOpFn marshalling_op_; // Marshalling ops handler.
- const InitialValGenFunc initial_value_gen_; // Makes flag's initial value.
+ const FlagOpFn op_; // Type-specific handler.
+ const FlagMarshallingOpFn marshalling_op_; // Marshalling ops handler.
const FlagHelpSrc help_; // Help message literal or function to generate it.
// Indicates if help message was supplied as literal or generator func.
const FlagHelpSrcKind help_source_kind_;
- // Mutable Flag's data. (guarded by locks_->primary_mu).
- // Indicates that locks_, cur_ and def_ fields have been lazily initialized.
+ // Mutable Flag's data. (guarded by DataGuard()).
+ // Indicates that locks_ and cur_ fields have been lazily initialized.
std::atomic<bool> inited_{false};
// Has flag value been modified?
- bool modified_ ABSL_GUARDED_BY(locks_->primary_mu) = false;
+ bool modified_ ABSL_GUARDED_BY(*DataGuard()) = false;
// Specified on command line.
- bool on_command_line_ ABSL_GUARDED_BY(locks_->primary_mu) = false;
- // Lazily initialized pointer to default value
- void* def_ ABSL_GUARDED_BY(locks_->primary_mu) = nullptr;
+ bool on_command_line_ ABSL_GUARDED_BY(*DataGuard()) = false;
+ // If def_kind_ == kDynamicValue, default_src_ holds a dynamically allocated
+ // value.
+ FlagDefaultSrcKind def_kind_ ABSL_GUARDED_BY(*DataGuard());
+ // Either a pointer to the function generating the default value based on the
+ // value specified in ABSL_FLAG or pointer to the dynamically set default
+ // value via SetCommandLineOptionWithMode. def_kind_ is used to distinguish
+ // these two cases.
+ FlagDefaultSrc default_src_ ABSL_GUARDED_BY(*DataGuard());
// Lazily initialized pointer to current value
- void* cur_ ABSL_GUARDED_BY(locks_->primary_mu) = nullptr;
+ void* cur_ ABSL_GUARDED_BY(*DataGuard()) = nullptr;
// Mutation counter
- int64_t counter_ ABSL_GUARDED_BY(locks_->primary_mu) = 0;
+ int64_t counter_ ABSL_GUARDED_BY(*DataGuard()) = 0;
// For some types, a copy of the current value is kept in an atomically
// accessible field.
std::atomic<int64_t> atomic_{flags_internal::AtomicInit()};
@@ -263,7 +286,7 @@ class Flag final : public flags_internal::CommandLineFlag {
constexpr Flag(const char* name, const flags_internal::HelpInitArg help,
const char* filename,
const flags_internal::FlagMarshallingOpFn marshalling_op,
- const flags_internal::InitialValGenFunc initial_value_gen)
+ const flags_internal::FlagDfltGenFunc initial_value_gen)
: flags_internal::CommandLineFlag(name, filename),
impl_(&flags_internal::FlagOps<T>, marshalling_op, initial_value_gen,
help) {}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-09 15:00:43 +0000