| 1 |
#ifndef BENCHMARK_COMMANDLINEFLAGS_H_ |
| 2 |
#define BENCHMARK_COMMANDLINEFLAGS_H_ |
| 3 |
|
| 4 |
#include <cstdint> |
| 5 |
#include <map> |
| 6 |
#include <string> |
| 7 |
|
| 8 |
#include "benchmark/export.h" |
| 9 |
|
| 10 |
// Macro for referencing flags. |
| 11 |
#define FLAG(name) FLAGS_##name |
| 12 |
|
| 13 |
// Macros for declaring flags. |
| 14 |
#define BM_DECLARE_bool(name) BENCHMARK_EXPORT extern bool FLAG(name) |
| 15 |
#define BM_DECLARE_int32(name) BENCHMARK_EXPORT extern int32_t FLAG(name) |
| 16 |
#define BM_DECLARE_double(name) BENCHMARK_EXPORT extern double FLAG(name) |
| 17 |
#define BM_DECLARE_string(name) BENCHMARK_EXPORT extern std::string FLAG(name) |
| 18 |
#define BM_DECLARE_kvpairs(name) \ |
| 19 |
BENCHMARK_EXPORT extern std::map<std::string, std::string> FLAG(name) |
| 20 |
|
| 21 |
// Macros for defining flags. |
| 22 |
#define BM_DEFINE_bool(name, default_val) \ |
| 23 |
BENCHMARK_EXPORT bool FLAG(name) = benchmark::BoolFromEnv(#name, default_val) |
| 24 |
#define BM_DEFINE_int32(name, default_val) \ |
| 25 |
BENCHMARK_EXPORT int32_t FLAG(name) = \ |
| 26 |
benchmark::Int32FromEnv(#name, default_val) |
| 27 |
#define BM_DEFINE_double(name, default_val) \ |
| 28 |
BENCHMARK_EXPORT double FLAG(name) = \ |
| 29 |
benchmark::DoubleFromEnv(#name, default_val) |
| 30 |
#define BM_DEFINE_string(name, default_val) \ |
| 31 |
BENCHMARK_EXPORT std::string FLAG(name) = \ |
| 32 |
benchmark::StringFromEnv(#name, default_val) |
| 33 |
#define BM_DEFINE_kvpairs(name, default_val) \ |
| 34 |
BENCHMARK_EXPORT std::map<std::string, std::string> FLAG(name) = \ |
| 35 |
benchmark::KvPairsFromEnv(#name, default_val) |
| 36 |
|
| 37 |
namespace benchmark { |
| 38 |
|
| 39 |
// Parses a bool from the environment variable corresponding to the given flag. |
| 40 |
// |
| 41 |
// If the variable exists, returns IsTruthyFlagValue() value; if not, |
| 42 |
// returns the given default value. |
| 43 |
BENCHMARK_EXPORT |
| 44 |
bool BoolFromEnv(const char* flag, bool default_val); |
| 45 |
|
| 46 |
// Parses an Int32 from the environment variable corresponding to the given |
| 47 |
// flag. |
| 48 |
// |
| 49 |
// If the variable exists, returns ParseInt32() value; if not, returns |
| 50 |
// the given default value. |
| 51 |
BENCHMARK_EXPORT |
| 52 |
int32_t Int32FromEnv(const char* flag, int32_t default_val); |
| 53 |
|
| 54 |
// Parses an Double from the environment variable corresponding to the given |
| 55 |
// flag. |
| 56 |
// |
| 57 |
// If the variable exists, returns ParseDouble(); if not, returns |
| 58 |
// the given default value. |
| 59 |
BENCHMARK_EXPORT |
| 60 |
double DoubleFromEnv(const char* flag, double default_val); |
| 61 |
|
| 62 |
// Parses a string from the environment variable corresponding to the given |
| 63 |
// flag. |
| 64 |
// |
| 65 |
// If variable exists, returns its value; if not, returns |
| 66 |
// the given default value. |
| 67 |
BENCHMARK_EXPORT |
| 68 |
const char* StringFromEnv(const char* flag, const char* default_val); |
| 69 |
|
| 70 |
// Parses a set of kvpairs from the environment variable corresponding to the |
| 71 |
// given flag. |
| 72 |
// |
| 73 |
// If variable exists, returns its value; if not, returns |
| 74 |
// the given default value. |
| 75 |
BENCHMARK_EXPORT |
| 76 |
std::map<std::string, std::string> KvPairsFromEnv( |
| 77 |
const char* flag, std::map<std::string, std::string> default_val); |
| 78 |
|
| 79 |
// Parses a string for a bool flag, in the form of either |
| 80 |
// "--flag=value" or "--flag". |
| 81 |
// |
| 82 |
// In the former case, the value is taken as true if it passes IsTruthyValue(). |
| 83 |
// |
| 84 |
// In the latter case, the value is taken as true. |
| 85 |
// |
| 86 |
// On success, stores the value of the flag in *value, and returns |
| 87 |
// true. On failure, returns false without changing *value. |
| 88 |
BENCHMARK_EXPORT |
| 89 |
bool ParseBoolFlag(const char* str, const char* flag, bool* value); |
| 90 |
|
| 91 |
// Parses a string for an Int32 flag, in the form of "--flag=value". |
| 92 |
// |
| 93 |
// On success, stores the value of the flag in *value, and returns |
| 94 |
// true. On failure, returns false without changing *value. |
| 95 |
BENCHMARK_EXPORT |
| 96 |
bool ParseInt32Flag(const char* str, const char* flag, int32_t* value); |
| 97 |
|
| 98 |
// Parses a string for a Double flag, in the form of "--flag=value". |
| 99 |
// |
| 100 |
// On success, stores the value of the flag in *value, and returns |
| 101 |
// true. On failure, returns false without changing *value. |
| 102 |
BENCHMARK_EXPORT |
| 103 |
bool ParseDoubleFlag(const char* str, const char* flag, double* value); |
| 104 |
|
| 105 |
// Parses a string for a string flag, in the form of "--flag=value". |
| 106 |
// |
| 107 |
// On success, stores the value of the flag in *value, and returns |
| 108 |
// true. On failure, returns false without changing *value. |
| 109 |
BENCHMARK_EXPORT |
| 110 |
bool ParseStringFlag(const char* str, const char* flag, std::string* value); |
| 111 |
|
| 112 |
// Parses a string for a kvpairs flag in the form "--flag=key=value,key=value" |
| 113 |
// |
| 114 |
// On success, stores the value of the flag in *value and returns true. On |
| 115 |
// failure returns false, though *value may have been mutated. |
| 116 |
BENCHMARK_EXPORT |
| 117 |
bool ParseKeyValueFlag(const char* str, const char* flag, |
| 118 |
std::map<std::string, std::string>* value); |
| 119 |
|
| 120 |
// Returns true if the string matches the flag. |
| 121 |
BENCHMARK_EXPORT |
| 122 |
bool IsFlag(const char* str, const char* flag); |
| 123 |
|
| 124 |
// Returns true unless value starts with one of: '0', 'f', 'F', 'n' or 'N', or |
| 125 |
// some non-alphanumeric character. Also returns false if the value matches |
| 126 |
// one of 'no', 'false', 'off' (case-insensitive). As a special case, also |
| 127 |
// returns true if value is the empty string. |
| 128 |
BENCHMARK_EXPORT |
| 129 |
bool IsTruthyFlagValue(const std::string& value); |
| 130 |
|
| 131 |
} // end namespace benchmark |
| 132 |
|
| 133 |
#endif // BENCHMARK_COMMANDLINEFLAGS_H_ |