A class that holds option structs indexed by their type.
An "Option" is any struct that has a public Type
member typedef. By convention they are named like "FooOption". Each library (e.g., spanner, storage) may define their own set of options. Additionally, there are common options defined that many libraries may use. All these options may be set in a single Options
instance, and each library will look at the options that it needs.
Here's an overview of this class's interface, but see the method documentation below for details.
.set<T>(x)
– Sets the optionT
to valuex
.has<T>()
– Returns true iff optionT
is set.unset<T>()
– Removes the optionT
.get<T>()
– Gets a const-ref to the value of optionT
.lookup<T>(x)
– Gets a non-const-ref to optionT
's value, initializing it tox
if it was not set (x
is optional).
Example:
struct FooOption {
using Type = int;
};
struct BarOption {
using Type = std::set<std::string>;
};
...
Options opts;
assert(opts.get<FooOption>() == 0);
opts.set<FooOption>(42);
assert(opts.get<FooOption>() == 42);
// Inserts two elements directly into the BarOption's std::set.
opts.lookup<BarOption>().insert("hello");
opts.lookup<BarOption>().insert("world");
std::set<std::string> const& bar = opts.get<BarOption>();
assert(bar == std::set<std::string>{"hello", "world"});
Constructors
Options
Constructs an empty instance.
Options
Parameter | |
---|---|
Name | Description |
rhs |
Options const &
|
Options
Parameter | |
---|---|
Name | Description |
|
Options &&
|
Operators
operator=
Parameter | |
---|---|
Name | Description |
rhs |
Options const &
|
Returns | |
---|---|
Type | Description |
Options & |
operator=
Parameter | |
---|---|
Name | Description |
|
Options &&
|
Returns | |
---|---|
Type | Description |
Options & |
Functions
set
Sets option T
to the value v
and returns a reference to *this
.
struct FooOption {
using Type = int;
};
auto opts = Options{}.set<FooOption>(123);
Parameters | |
---|---|
Name | Description |
v |
ValueTypeT< T >
the value to set the option T |
typename T |
the option type |
Returns | |
---|---|
Type | Description |
Options & |
has
Returns true IFF an option with type T
exists.
Parameter | |
---|---|
Name | Description |
typename T |
the option type |
Returns | |
---|---|
Type | Description |
bool |
unset
Erases the option specified by the type T
.
Parameter | |
---|---|
Name | Description |
typename T |
the option type |
Returns | |
---|---|
Type | Description |
void |
get
Returns a reference to the value for T
, or a value-initialized default if T
was not set.
This method will always return a reference to a valid value of the correct type for option T
, whether or not T
has actually been set. Use has<T>()
to check whether or not the option has been set.
struct FooOption {
using Type = std::set<std::string>;
};
Options opts;
std::set<std::string> const& x = opts.get<FooOption>();
assert(x.empty());
assert(!x.has<FooOption>());
opts.set<FooOption>({"foo"});
assert(opts.get<FooOption>().size() == 1);
Parameter | |
---|---|
Name | Description |
typename T |
the option type |
Returns | |
---|---|
Type | Description |
ValueTypeT< T > const & |
lookup
Returns a reference to the value for option T
, setting the value to init_value
if necessary.
struct BigOption {
using Type = std::set<std::string>;
};
Options opts;
std::set<std::string>& x = opts.lookup<BigOption>();
assert(x.empty());
x.insert("foo");
opts.lookup<BigOption>().insert("bar");
assert(x.size() == 2);
Parameters | |
---|---|
Name | Description |
value |
ValueTypeT< T >
the initial value to use if |
typename T |
the option type |
Returns | |
---|---|
Type | Description |
ValueTypeT< T > & |