Windows平台下gflags库(已编译好的)

// Copyright (c) 2006, Google Inc. // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following disclaimer // in the documentation and/or other materials provided with the // distribution. // * Neither the name of Google Inc. nor the names of its // contributors may be used to endorse or promote products derived from // this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // --- // Revamped and reorganized by Craig Silverstein // // This is the file that should be included by any file which declares // or defines a command line flag or wants to parse command line flags // or print a program usage message (which will include information about // flags). Executive summary, in the form of an example foo.cc file: // // #include "foo.h" // foo.h has a line "DECLARE_int32(start);" // #include "validators.h" // hypothetical file defining ValidateIsFile() // // DEFINE_int32(end, 1000, "The last record to read"); // // DEFINE_string(filename, "my_file.txt", "The file to read"); // // Crash if the specified file does not exist. // static bool dummy = RegisterFlagValidator(&FLAGS_filename, // &ValidateIsFile); // // DECLARE_bool(verbose); // some other file has a DEFINE_bool(verbose, ...) // // void MyFunc() { // if (FLAGS_verbose) printf("Records %d-%d\n", FLAGS_start, FLAGS_end); // } // // Then, at the command-line: // ./foo --noverbose --start=5 --end=100 // // For more details, see // doc/gflags.html // // --- A note about thread-safety: // // We describe many functions in this routine as being thread-hostile, // thread-compatible, or thread-safe. Here are the meanings we use: // // thread-safe: it is safe for multiple threads to call this routine // (or, when referring to a class, methods of this class) // concurrently. // thread-hostile: it is not safe for multiple threads to call this // routine (or methods of this class) concurrently. In gflags, // most thread-hostile routines are intended to be called early in, // or even before, main() -- that is, before threads are spawned. // thread-compatible: it is safe for multiple threads to read from // this variable (when applied to variables), or to call const // methods of this class (when applied to classes), as long as no // other thread is writing to the variable or calling non-const // methods of this class. #ifndef GFLAGS_GFLAGS_H_ #define GFLAGS_GFLAGS_H_ #include <string> #include <vector> #include "gflags_declare.h" // IWYU pragma: export // We always want to export variables defined in user code #ifndef GFLAGS_DLL_DEFINE_FLAG # ifdef _MSC_VER # define GFLAGS_DLL_DEFINE_FLAG __declspec(dllexport) # else # define GFLAGS_DLL_DEFINE_FLAG # endif #endif namespace gflags { // -------------------------------------------------------------------- // To actually define a flag in a file, use DEFINE_bool, // DEFINE_string, etc. at the bottom of this file. You may also find // it useful to register a validator with the flag. This ensures that // when the flag is parsed from the commandline, or is later set via // SetCommandLineOption, we call the validation function. It is _not_ // called when you assign the value to the flag directly using the = operator. // // The validation function should return true if the flag value is valid, and // false otherwise. If the function returns false for the new setting of the // flag, the flag will retain its current value. If it returns false for the // default value, ParseCommandLineFlags() will die. // // This function is safe to call at global construct time (as in the // example below). // // Example use: // static bool ValidatePort(const char* flagname, int32 value) { // if (value > 0 && value < 32768) // value is ok // return true; // printf("Invalid value for --%s: %d\n", flagname, (int)value); // return false; // } // DEFINE_int32(port, 0, "What port to listen on"); // static bool dummy = RegisterFlagValidator(&FLAGS_port, &ValidatePort); // Returns true if successfully registered, false if not (because the // first argument doesn't point to a command-line flag, or because a // validator is already registered for this flag). extern GFLAGS_DLL_DECL bool RegisterFlagValidator(const bool* flag, bool (*validate_fn)(const char*, bool)); extern GFLAGS_DLL_DECL bool RegisterFlagValidator(const int32* flag, bool (*validate_fn)(const char*, int32)); extern GFLAGS_DLL_DECL bool RegisterFlagValidator(const int64* flag, bool (*validate_fn)(const char*, int64)); extern GFLAGS_DLL_DECL bool RegisterFlagValidator(const uint64* flag, bool (*validate_fn)(const char*, uint64)); extern GFLAGS_DLL_DECL bool RegisterFlagValidator(const double* flag, bool (*validate_fn)(const char*, double)); extern GFLAGS_DLL_DECL bool RegisterFlagValidator(const std::string* flag, bool (*validate_fn)(const char*, const std::string&)); // Convenience macro for the registration of a flag validator #define DEFINE_validator(name, validator) \ static const bool name##_validator_registered = \ gflags::RegisterFlagValidator(&FLAGS_##name, validator) // -------------------------------------------------------------------- // These methods are the best way to get access to info about the // list of commandline flags. Note that these routines are pretty slow. // GetAllFlags: mostly-complete info about the list, sorted by file. // ShowUsageWithFlags: pretty-prints the list to stdout (what --help does) // ShowUsageWithFlagsRestrict: limit to filenames with restrict as a substr // // In addition to accessing flags, you can also access argv[0] (the program // name) and argv (the entire commandline), which we sock away a copy of. // These variables are static, so you should only set them once. // // No need to export this data only structure from DLL, avoiding VS warning 4251. struct CommandLineFlagInfo { std::string name; // the name of the flag std::string type; // the type of the flag: int32, etc std::string description; // the "help text" associated with the flag std::string current_value; // the current value, as a string std::string default_value; // the default value, as a string std::string filename; // 'cleaned' version of filename holding the flag bool has_validator_fn; // true if RegisterFlagValidator called on this flag bool is_default; // true if the flag has the default value and // has not been set explicitly from the cmdline