quickstep-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jianq...@apache.org
Subject [44/55] [abbrv] incubator-quickstep git commit: Removed redundant third party libraries shared by both Quickstep and TMB.
Date Thu, 09 Mar 2017 21:32:23 GMT
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/f8cf7fba/third_party/src/tmb/third_party/gflags/src/gflags.h.in
----------------------------------------------------------------------
diff --git a/third_party/src/tmb/third_party/gflags/src/gflags.h.in b/third_party/src/tmb/third_party/gflags/src/gflags.h.in
deleted file mode 100644
index 0324d39..0000000
--- a/third_party/src/tmb/third_party/gflags/src/gflags.h.in
+++ /dev/null
@@ -1,572 +0,0 @@
-// 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_NAMESPACE {
-
-
-// --------------------------------------------------------------------
-// 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_NAMESPACE::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
-                               // or via SetCommandLineOption
-  const void* flag_ptr;        // pointer to the flag's current value (i.e. FLAGS_foo)
-};
-
-// Using this inside of a validator is a recipe for a deadlock.
-// TODO(user) Fix locking when validators are running, to make it safe to
-// call validators during ParseAllFlags.
-// Also make sure then to uncomment the corresponding unit test in
-// gflags_unittest.sh
-extern GFLAGS_DLL_DECL void GetAllFlags(std::vector<CommandLineFlagInfo>* OUTPUT);
-// These two are actually defined in gflags_reporting.cc.
-extern GFLAGS_DLL_DECL void ShowUsageWithFlags(const char *argv0);  // what --help does
-extern GFLAGS_DLL_DECL void ShowUsageWithFlagsRestrict(const char *argv0, const char *restrict);
-
-// Create a descriptive string for a flag.
-// Goes to some trouble to make pretty line breaks.
-extern GFLAGS_DLL_DECL std::string DescribeOneFlag(const CommandLineFlagInfo& flag);
-
-// Thread-hostile; meant to be called before any threads are spawned.
-extern GFLAGS_DLL_DECL void SetArgv(int argc, const char** argv);
-
-// The following functions are thread-safe as long as SetArgv() is
-// only called before any threads start.
-extern GFLAGS_DLL_DECL const std::vector<std::string>& GetArgvs();
-extern GFLAGS_DLL_DECL const char* GetArgv();                      // all of argv as a string
-extern GFLAGS_DLL_DECL const char* GetArgv0();                     // only argv0
-extern GFLAGS_DLL_DECL uint32 GetArgvSum();                        // simple checksum of argv
-extern GFLAGS_DLL_DECL const char* ProgramInvocationName();        // argv0, or "UNKNOWN" if not set
-extern GFLAGS_DLL_DECL const char* ProgramInvocationShortName();   // basename(argv0)
-
-// ProgramUsage() is thread-safe as long as SetUsageMessage() is only
-// called before any threads start.
-extern GFLAGS_DLL_DECL const char* ProgramUsage();                 // string set by SetUsageMessage()
-
-// VersionString() is thread-safe as long as SetVersionString() is only
-// called before any threads start.
-extern GFLAGS_DLL_DECL const char* VersionString();                // string set by SetVersionString()
-
-
-
-// --------------------------------------------------------------------
-// Normally you access commandline flags by just saying "if (FLAGS_foo)"
-// or whatever, and set them by calling "FLAGS_foo = bar" (or, more
-// commonly, via the DEFINE_foo macro).  But if you need a bit more
-// control, we have programmatic ways to get/set the flags as well.
-// These programmatic ways to access flags are thread-safe, but direct
-// access is only thread-compatible.
-
-// Return true iff the flagname was found.
-// OUTPUT is set to the flag's value, or unchanged if we return false.
-extern GFLAGS_DLL_DECL bool GetCommandLineOption(const char* name, std::string* OUTPUT);
-
-// Return true iff the flagname was found. OUTPUT is set to the flag's
-// CommandLineFlagInfo or unchanged if we return false.
-extern GFLAGS_DLL_DECL bool GetCommandLineFlagInfo(const char* name, CommandLineFlagInfo* OUTPUT);
-
-// Return the CommandLineFlagInfo of the flagname.  exit() if name not found.
-// Example usage, to check if a flag's value is currently the default value:
-//   if (GetCommandLineFlagInfoOrDie("foo").is_default) ...
-extern GFLAGS_DLL_DECL CommandLineFlagInfo GetCommandLineFlagInfoOrDie(const char* name);
-
-enum GFLAGS_DLL_DECL FlagSettingMode {
-  // update the flag's value (can call this multiple times).
-  SET_FLAGS_VALUE,
-  // update the flag's value, but *only if* it has not yet been updated
-  // with SET_FLAGS_VALUE, SET_FLAG_IF_DEFAULT, or "FLAGS_xxx = nondef".
-  SET_FLAG_IF_DEFAULT,
-  // set the flag's default value to this.  If the flag has not yet updated
-  // yet (via SET_FLAGS_VALUE, SET_FLAG_IF_DEFAULT, or "FLAGS_xxx = nondef")
-  // change the flag's current value to the new default value as well.
-  SET_FLAGS_DEFAULT
-};
-
-// Set a particular flag ("command line option").  Returns a string
-// describing the new value that the option has been set to.  The
-// return value API is not well-specified, so basically just depend on
-// it to be empty if the setting failed for some reason -- the name is
-// not a valid flag name, or the value is not a valid value -- and
-// non-empty else.
-
-// SetCommandLineOption uses set_mode == SET_FLAGS_VALUE (the common case)
-extern GFLAGS_DLL_DECL std::string SetCommandLineOption        (const char* name, const char* value);
-extern GFLAGS_DLL_DECL std::string SetCommandLineOptionWithMode(const char* name, const char* value, FlagSettingMode set_mode);
-
-
-// --------------------------------------------------------------------
-// Saves the states (value, default value, whether the user has set
-// the flag, registered validators, etc) of all flags, and restores
-// them when the FlagSaver is destroyed.  This is very useful in
-// tests, say, when you want to let your tests change the flags, but
-// make sure that they get reverted to the original states when your
-// test is complete.
-//
-// Example usage:
-//   void TestFoo() {
-//     FlagSaver s1;
-//     FLAG_foo = false;
-//     FLAG_bar = "some value";
-//
-//     // test happens here.  You can return at any time
-//     // without worrying about restoring the FLAG values.
-//   }
-//
-// Note: This class is marked with GFLAGS_ATTRIBUTE_UNUSED because all
-// the work is done in the constructor and destructor, so in the standard
-// usage example above, the compiler would complain that it's an
-// unused variable.
-//
-// This class is thread-safe.  However, its destructor writes to
-// exactly the set of flags that have changed value during its
-// lifetime, so concurrent _direct_ access to those flags
-// (i.e. FLAGS_foo instead of {Get,Set}CommandLineOption()) is unsafe.
-
-class GFLAGS_DLL_DECL FlagSaver {
- public:
-  FlagSaver();
-  ~FlagSaver();
-
- private:
-  class FlagSaverImpl* impl_;   // we use pimpl here to keep API steady
-
-  FlagSaver(const FlagSaver&);  // no copying!
-  void operator=(const FlagSaver&);
-}@GFLAGS_ATTRIBUTE_UNUSED@;
-
-// --------------------------------------------------------------------
-// Some deprecated or hopefully-soon-to-be-deprecated functions.
-
-// This is often used for logging.  TODO(csilvers): figure out a better way
-extern GFLAGS_DLL_DECL std::string CommandlineFlagsIntoString();
-// Usually where this is used, a FlagSaver should be used instead.
-extern GFLAGS_DLL_DECL
-bool ReadFlagsFromString(const std::string& flagfilecontents,
-                         const char* prog_name,
-                         bool errors_are_fatal);  // uses SET_FLAGS_VALUE
-
-// These let you manually implement --flagfile functionality.
-// DEPRECATED.
-extern GFLAGS_DLL_DECL bool AppendFlagsIntoFile(const std::string& filename, const char* prog_name);
-extern GFLAGS_DLL_DECL bool ReadFromFlagsFile(const std::string& filename, const char* prog_name, bool errors_are_fatal);   // uses SET_FLAGS_VALUE
-
-
-// --------------------------------------------------------------------
-// Useful routines for initializing flags from the environment.
-// In each case, if 'varname' does not exist in the environment
-// return defval.  If 'varname' does exist but is not valid
-// (e.g., not a number for an int32 flag), abort with an error.
-// Otherwise, return the value.  NOTE: for booleans, for true use
-// 't' or 'T' or 'true' or '1', for false 'f' or 'F' or 'false' or '0'.
-
-extern GFLAGS_DLL_DECL bool BoolFromEnv(const char *varname, bool defval);
-extern GFLAGS_DLL_DECL int32 Int32FromEnv(const char *varname, int32 defval);
-extern GFLAGS_DLL_DECL int64 Int64FromEnv(const char *varname, int64 defval);
-extern GFLAGS_DLL_DECL uint64 Uint64FromEnv(const char *varname, uint64 defval);
-extern GFLAGS_DLL_DECL double DoubleFromEnv(const char *varname, double defval);
-extern GFLAGS_DLL_DECL const char *StringFromEnv(const char *varname, const char *defval);
-
-
-// --------------------------------------------------------------------
-// The next two functions parse gflags from main():
-
-// Set the "usage" message for this program.  For example:
-//   string usage("This program does nothing.  Sample usage:\n");
-//   usage += argv[0] + " <uselessarg1> <uselessarg2>";
-//   SetUsageMessage(usage);
-// Do not include commandline flags in the usage: we do that for you!
-// Thread-hostile; meant to be called before any threads are spawned.
-extern GFLAGS_DLL_DECL void SetUsageMessage(const std::string& usage);
-
-// Sets the version string, which is emitted with --version.
-// For instance: SetVersionString("1.3");
-// Thread-hostile; meant to be called before any threads are spawned.
-extern GFLAGS_DLL_DECL void SetVersionString(const std::string& version);
-
-
-// Looks for flags in argv and parses them.  Rearranges argv to put
-// flags first, or removes them entirely if remove_flags is true.
-// If a flag is defined more than once in the command line or flag
-// file, the last definition is used.  Returns the index (into argv)
-// of the first non-flag argument.
-// See top-of-file for more details on this function.
-#ifndef SWIG   // In swig, use ParseCommandLineFlagsScript() instead.
-extern GFLAGS_DLL_DECL uint32 ParseCommandLineFlags(int *argc, char*** argv, bool remove_flags);
-#endif
-
-
-// Calls to ParseCommandLineNonHelpFlags and then to
-// HandleCommandLineHelpFlags can be used instead of a call to
-// ParseCommandLineFlags during initialization, in order to allow for
-// changing default values for some FLAGS (via
-// e.g. SetCommandLineOptionWithMode calls) between the time of
-// command line parsing and the time of dumping help information for
-// the flags as a result of command line parsing.  If a flag is
-// defined more than once in the command line or flag file, the last
-// definition is used.  Returns the index (into argv) of the first
-// non-flag argument.  (If remove_flags is true, will always return 1.)
-extern GFLAGS_DLL_DECL uint32 ParseCommandLineNonHelpFlags(int *argc, char*** argv, bool remove_flags);
-
-// This is actually defined in gflags_reporting.cc.
-// This function is misnamed (it also handles --version, etc.), but
-// it's too late to change that now. :-(
-extern GFLAGS_DLL_DECL void HandleCommandLineHelpFlags();   // in gflags_reporting.cc
-
-// Allow command line reparsing.  Disables the error normally
-// generated when an unknown flag is found, since it may be found in a
-// later parse.  Thread-hostile; meant to be called before any threads
-// are spawned.
-extern GFLAGS_DLL_DECL void AllowCommandLineReparsing();
-
-// Reparse the flags that have not yet been recognized.  Only flags
-// registered since the last parse will be recognized.  Any flag value
-// must be provided as part of the argument using "=", not as a
-// separate command line argument that follows the flag argument.
-// Intended for handling flags from dynamically loaded libraries,
-// since their flags are not registered until they are loaded.
-extern GFLAGS_DLL_DECL void ReparseCommandLineNonHelpFlags();
-
-// Clean up memory allocated by flags.  This is only needed to reduce
-// the quantity of "potentially leaked" reports emitted by memory
-// debugging tools such as valgrind.  It is not required for normal
-// operation, or for the google perftools heap-checker.  It must only
-// be called when the process is about to exit, and all threads that
-// might access flags are quiescent.  Referencing flags after this is
-// called will have unexpected consequences.  This is not safe to run
-// when multiple threads might be running: the function is
-// thread-hostile.
-extern GFLAGS_DLL_DECL void ShutDownCommandLineFlags();
-
-
-// --------------------------------------------------------------------
-// Now come the command line flag declaration/definition macros that
-// will actually be used.  They're kind of hairy.  A major reason
-// for this is initialization: we want people to be able to access
-// variables in global constructors and have that not crash, even if
-// their global constructor runs before the global constructor here.
-// (Obviously, we can't guarantee the flags will have the correct
-// default value in that case, but at least accessing them is safe.)
-// The only way to do that is have flags point to a static buffer.
-// So we make one, using a union to ensure proper alignment, and
-// then use placement-new to actually set up the flag with the
-// correct default value.  In the same vein, we have to worry about
-// flag access in global destructors, so FlagRegisterer has to be
-// careful never to destroy the flag-values it constructs.
-//
-// Note that when we define a flag variable FLAGS_<name>, we also
-// preemptively define a junk variable, FLAGS_no<name>.  This is to
-// cause a link-time error if someone tries to define 2 flags with
-// names like "logging" and "nologging".  We do this because a bool
-// flag FLAG can be set from the command line to true with a "-FLAG"
-// argument, and to false with a "-noFLAG" argument, and so this can
-// potentially avert confusion.
-//
-// We also put flags into their own namespace.  It is purposefully
-// named in an opaque way that people should have trouble typing
-// directly.  The idea is that DEFINE puts the flag in the weird
-// namespace, and DECLARE imports the flag from there into the current
-// namespace.  The net result is to force people to use DECLARE to get
-// access to a flag, rather than saying "extern GFLAGS_DLL_DECL bool FLAGS_whatever;"
-// or some such instead.  We want this so we can put extra
-// functionality (like sanity-checking) in DECLARE if we want, and
-// make sure it is picked up everywhere.
-//
-// We also put the type of the variable in the namespace, so that
-// people can't DECLARE_int32 something that they DEFINE_bool'd
-// elsewhere.
-
-class GFLAGS_DLL_DECL FlagRegisterer {
- public:
-  FlagRegisterer(const char* name, const char* type,
-                 const char* help, const char* filename,
-                 void* current_storage, void* defvalue_storage);
-};
-
-// If your application #defines STRIP_FLAG_HELP to a non-zero value
-// before #including this file, we remove the help message from the
-// binary file. This can reduce the size of the resulting binary
-// somewhat, and may also be useful for security reasons.
-
-extern GFLAGS_DLL_DECL const char kStrippedFlagHelp[];
-
-
-} // namespace GFLAGS_NAMESPACE
-
-
-#ifndef SWIG  // In swig, ignore the main flag declarations
-
-#if defined(STRIP_FLAG_HELP) && STRIP_FLAG_HELP > 0
-// Need this construct to avoid the 'defined but not used' warning.
-#define MAYBE_STRIPPED_HELP(txt) \
-   (false ? (txt) : GFLAGS_NAMESPACE::kStrippedFlagHelp)
-#else
-#define MAYBE_STRIPPED_HELP(txt) txt
-#endif
-
-// Each command-line flag has two variables associated with it: one
-// with the current value, and one with the default value.  However,
-// we have a third variable, which is where value is assigned; it's a
-// constant.  This guarantees that FLAG_##value is initialized at
-// static initialization time (e.g. before program-start) rather than
-// than global construction time (which is after program-start but
-// before main), at least when 'value' is a compile-time constant.  We
-// use a small trick for the "default value" variable, and call it
-// FLAGS_no<name>.  This serves the second purpose of assuring a
-// compile error if someone tries to define a flag named no<name>
-// which is illegal (--foo and --nofoo both affect the "foo" flag).
-#define DEFINE_VARIABLE(type, shorttype, name, value, help)             \
-  namespace fL##shorttype {                                             \
-    static const type FLAGS_nono##name = value;                         \
-    /* We always want to export defined variables, dll or no */         \
-    GFLAGS_DLL_DEFINE_FLAG type FLAGS_##name = FLAGS_nono##name;        \
-    type FLAGS_no##name = FLAGS_nono##name;                             \
-    static GFLAGS_NAMESPACE::FlagRegisterer o_##name(                   \
-      #name, #type, MAYBE_STRIPPED_HELP(help), __FILE__,                \
-      &FLAGS_##name, &FLAGS_no##name);                                  \
-  }                                                                     \
-  using fL##shorttype::FLAGS_##name
-
-// For DEFINE_bool, we want to do the extra check that the passed-in
-// value is actually a bool, and not a string or something that can be
-// coerced to a bool.  These declarations (no definition needed!) will
-// help us do that, and never evaluate From, which is important.
-// We'll use 'sizeof(IsBool(val))' to distinguish. This code requires
-// that the compiler have different sizes for bool & double. Since
-// this is not guaranteed by the standard, we check it with a
-// COMPILE_ASSERT.
-namespace fLB {
-struct CompileAssert {};
-typedef CompileAssert expected_sizeof_double_neq_sizeof_bool[
-                      (sizeof(double) != sizeof(bool)) ? 1 : -1];
-template<typename From> double GFLAGS_DLL_DECL IsBoolFlag(const From& from);
-GFLAGS_DLL_DECL bool IsBoolFlag(bool from);
-}  // namespace fLB
-
-// Here are the actual DEFINE_*-macros. The respective DECLARE_*-macros
-// are in a separate include, gflags_declare.h, for reducing
-// the physical transitive size for DECLARE use.
-#define DEFINE_bool(name, val, txt)                                     \
-  namespace fLB {                                                       \
-    typedef ::fLB::CompileAssert FLAG_##name##_value_is_not_a_bool[     \
-            (sizeof(::fLB::IsBoolFlag(val)) != sizeof(double))? 1: -1]; \
-  }                                                                     \
-  DEFINE_VARIABLE(bool, B, name, val, txt)
-
-#define DEFINE_int32(name, val, txt) \
-   DEFINE_VARIABLE(GFLAGS_NAMESPACE::int32, I, \
-                   name, val, txt)
-
-#define DEFINE_int64(name, val, txt) \
-   DEFINE_VARIABLE(GFLAGS_NAMESPACE::int64, I64, \
-                   name, val, txt)
-
-#define DEFINE_uint64(name,val, txt) \
-   DEFINE_VARIABLE(GFLAGS_NAMESPACE::uint64, U64, \
-                   name, val, txt)
-
-#define DEFINE_double(name, val, txt) \
-   DEFINE_VARIABLE(double, D, name, val, txt)
-
-// Strings are trickier, because they're not a POD, so we can't
-// construct them at static-initialization time (instead they get
-// constructed at global-constructor time, which is much later).  To
-// try to avoid crashes in that case, we use a char buffer to store
-// the string, which we can static-initialize, and then placement-new
-// into it later.  It's not perfect, but the best we can do.
-
-namespace fLS {
-
-inline clstring* dont_pass0toDEFINE_string(char *stringspot,
-                                           const char *value) {
-  return new(stringspot) clstring(value);
-}
-inline clstring* dont_pass0toDEFINE_string(char *stringspot,
-                                           const clstring &value) {
-  return new(stringspot) clstring(value);
-}
-inline clstring* dont_pass0toDEFINE_string(char *stringspot,
-                                           int value);
-}  // namespace fLS
-
-// We need to define a var named FLAGS_no##name so people don't define
-// --string and --nostring.  And we need a temporary place to put val
-// so we don't have to evaluate it twice.  Two great needs that go
-// great together!
-// The weird 'using' + 'extern' inside the fLS namespace is to work around
-// an unknown compiler bug/issue with the gcc 4.2.1 on SUSE 10.  See
-//    http://code.google.com/p/google-gflags/issues/detail?id=20
-#define DEFINE_string(name, val, txt)                                       \
-  namespace fLS {                                                           \
-    using ::fLS::clstring;                                                  \
-    static union { void* align; char s[sizeof(clstring)]; } s_##name[2];    \
-    clstring* const FLAGS_no##name = ::fLS::                                \
-                                   dont_pass0toDEFINE_string(s_##name[0].s, \
-                                                             val);          \
-    static GFLAGS_NAMESPACE::FlagRegisterer o_##name(                       \
-        #name, "string", MAYBE_STRIPPED_HELP(txt), __FILE__,                \
-        s_##name[0].s, new (s_##name[1].s) clstring(*FLAGS_no##name));      \
-    extern GFLAGS_DLL_DEFINE_FLAG clstring& FLAGS_##name;                   \
-    using fLS::FLAGS_##name;                                                \
-    clstring& FLAGS_##name = *FLAGS_no##name;                               \
-  }                                                                         \
-  using fLS::FLAGS_##name
-
-#endif  // SWIG
-
-
-@INCLUDE_GFLAGS_NS_H@
-
-
-#endif  // GFLAGS_GFLAGS_H_

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/f8cf7fba/third_party/src/tmb/third_party/gflags/src/gflags_completions.cc
----------------------------------------------------------------------
diff --git a/third_party/src/tmb/third_party/gflags/src/gflags_completions.cc b/third_party/src/tmb/third_party/gflags/src/gflags_completions.cc
deleted file mode 100644
index 3a47623..0000000
--- a/third_party/src/tmb/third_party/gflags/src/gflags_completions.cc
+++ /dev/null
@@ -1,769 +0,0 @@
-// Copyright (c) 2008, 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.
-//
-// ---
-
-// Bash-style command line flag completion for C++ binaries
-//
-// This module implements bash-style completions.  It achieves this
-// goal in the following broad chunks:
-//
-//  1) Take a to-be-completed word, and examine it for search hints
-//  2) Identify all potentially matching flags
-//     2a) If there are no matching flags, do nothing.
-//     2b) If all matching flags share a common prefix longer than the
-//         completion word, output just that matching prefix
-//  3) Categorize those flags to produce a rough ordering of relevence.
-//  4) Potentially trim the set of flags returned to a smaller number
-//     that bash is happier with
-//  5) Output the matching flags in groups ordered by relevence.
-//     5a) Force bash to place most-relevent groups at the top of the list
-//     5b) Trim most flag's descriptions to fit on a single terminal line
-
-
-#include "config.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>   // for strlen
-
-#include <set>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "gflags.h"
-#include "util.h"
-
-using std::set;
-using std::string;
-using std::vector;
-
-
-DEFINE_string(tab_completion_word, "",
-              "If non-empty, HandleCommandLineCompletions() will hijack the "
-              "process and attempt to do bash-style command line flag "
-              "completion on this value.");
-DEFINE_int32(tab_completion_columns, 80,
-             "Number of columns to use in output for tab completion");
-
-
-namespace GFLAGS_NAMESPACE {
-
-
-namespace {
-// Function prototypes and Type forward declarations.  Code may be
-// more easily understood if it is roughly ordered according to
-// control flow, rather than by C's "declare before use" ordering
-struct CompletionOptions;
-struct NotableFlags;
-
-// The entry point if flag completion is to be used.
-static void PrintFlagCompletionInfo(void);
-
-
-// 1) Examine search word
-static void CanonicalizeCursorWordAndSearchOptions(
-    const string &cursor_word,
-    string *canonical_search_token,
-    CompletionOptions *options);
-
-static bool RemoveTrailingChar(string *str, char c);
-
-
-// 2) Find all matches
-static void FindMatchingFlags(
-    const vector<CommandLineFlagInfo> &all_flags,
-    const CompletionOptions &options,
-    const string &match_token,
-    set<const CommandLineFlagInfo *> *all_matches,
-    string *longest_common_prefix);
-
-static bool DoesSingleFlagMatch(
-    const CommandLineFlagInfo &flag,
-    const CompletionOptions &options,
-    const string &match_token);
-
-
-// 3) Categorize matches
-static void CategorizeAllMatchingFlags(
-    const set<const CommandLineFlagInfo *> &all_matches,
-    const string &search_token,
-    const string &module,
-    const string &package_dir,
-    NotableFlags *notable_flags);
-
-static void TryFindModuleAndPackageDir(
-    const vector<CommandLineFlagInfo> all_flags,
-    string *module,
-    string *package_dir);
-
-
-// 4) Decide which flags to use
-static void FinalizeCompletionOutput(
-    const set<const CommandLineFlagInfo *> &matching_flags,
-    CompletionOptions *options,
-    NotableFlags *notable_flags,
-    vector<string> *completions);
-
-static void RetrieveUnusedFlags(
-    const set<const CommandLineFlagInfo *> &matching_flags,
-    const NotableFlags &notable_flags,
-    set<const CommandLineFlagInfo *> *unused_flags);
-
-
-// 5) Output matches
-static void OutputSingleGroupWithLimit(
-    const set<const CommandLineFlagInfo *> &group,
-    const string &line_indentation,
-    const string &header,
-    const string &footer,
-    bool long_output_format,
-    int *remaining_line_limit,
-    size_t *completion_elements_added,
-    vector<string> *completions);
-
-// (helpers for #5)
-static string GetShortFlagLine(
-    const string &line_indentation,
-    const CommandLineFlagInfo &info);
-
-static string GetLongFlagLine(
-    const string &line_indentation,
-    const CommandLineFlagInfo &info);
-
-
-//
-// Useful types
-
-// Try to deduce the intentions behind this completion attempt.  Return the
-// canonical search term in 'canonical_search_token'.  Binary search options
-// are returned in the various booleans, which should all have intuitive
-// semantics, possibly except:
-//  - return_all_matching_flags: Generally, we'll trim the number of
-//    returned candidates to some small number, showing those that are
-//    most likely to be useful first.  If this is set, however, the user
-//    really does want us to return every single flag as an option.
-//  - force_no_update: Any time we output lines, all of which share a
-//    common prefix, bash will 'helpfully' not even bother to show the
-//    output, instead changing the current word to be that common prefix.
-//    If it's clear this shouldn't happen, we'll set this boolean
-struct CompletionOptions {
-  bool flag_name_substring_search;
-  bool flag_location_substring_search;
-  bool flag_description_substring_search;
-  bool return_all_matching_flags;
-  bool force_no_update;
-};
-
-// Notable flags are flags that are special or preferred for some
-// reason.  For example, flags that are defined in the binary's module
-// are expected to be much more relevent than flags defined in some
-// other random location.  These sets are specified roughly in precedence
-// order.  Once a flag is placed in one of these 'higher' sets, it won't
-// be placed in any of the 'lower' sets.
-struct NotableFlags {
-  typedef set<const CommandLineFlagInfo *> FlagSet;
-  FlagSet perfect_match_flag;
-  FlagSet module_flags;       // Found in module file
-  FlagSet package_flags;      // Found in same directory as module file
-  FlagSet most_common_flags;  // One of the XXX most commonly supplied flags
-  FlagSet subpackage_flags;   // Found in subdirectories of package
-};
-
-
-//
-// Tab completion implementation - entry point
-static void PrintFlagCompletionInfo(void) {
-  string cursor_word = FLAGS_tab_completion_word;
-  string canonical_token;
-  CompletionOptions options = { };
-  CanonicalizeCursorWordAndSearchOptions(
-      cursor_word,
-      &canonical_token,
-      &options);
-
-  DVLOG(1) << "Identified canonical_token: '" << canonical_token << "'";
-
-  vector<CommandLineFlagInfo> all_flags;
-  set<const CommandLineFlagInfo *> matching_flags;
-  GetAllFlags(&all_flags);
-  DVLOG(2) << "Found " << all_flags.size() << " flags overall";
-
-  string longest_common_prefix;
-  FindMatchingFlags(
-      all_flags,
-      options,
-      canonical_token,
-      &matching_flags,
-      &longest_common_prefix);
-  DVLOG(1) << "Identified " << matching_flags.size() << " matching flags";
-  DVLOG(1) << "Identified " << longest_common_prefix
-          << " as longest common prefix.";
-  if (longest_common_prefix.size() > canonical_token.size()) {
-    // There's actually a shared common prefix to all matching flags,
-    // so may as well output that and quit quickly.
-    DVLOG(1) << "The common prefix '" << longest_common_prefix
-            << "' was longer than the token '" << canonical_token
-            << "'.  Returning just this prefix for completion.";
-    fprintf(stdout, "--%s", longest_common_prefix.c_str());
-    return;
-  }
-  if (matching_flags.empty()) {
-    VLOG(1) << "There were no matching flags, returning nothing.";
-    return;
-  }
-
-  string module;
-  string package_dir;
-  TryFindModuleAndPackageDir(all_flags, &module, &package_dir);
-  DVLOG(1) << "Identified module: '" << module << "'";
-  DVLOG(1) << "Identified package_dir: '" << package_dir << "'";
-
-  NotableFlags notable_flags;
-  CategorizeAllMatchingFlags(
-      matching_flags,
-      canonical_token,
-      module,
-      package_dir,
-      &notable_flags);
-  DVLOG(2) << "Categorized matching flags:";
-  DVLOG(2) << " perfect_match: " << notable_flags.perfect_match_flag.size();
-  DVLOG(2) << " module: " << notable_flags.module_flags.size();
-  DVLOG(2) << " package: " << notable_flags.package_flags.size();
-  DVLOG(2) << " most common: " << notable_flags.most_common_flags.size();
-  DVLOG(2) << " subpackage: " << notable_flags.subpackage_flags.size();
-
-  vector<string> completions;
-  FinalizeCompletionOutput(
-      matching_flags,
-      &options,
-      &notable_flags,
-      &completions);
-
-  if (options.force_no_update)
-    completions.push_back("~");
-
-  DVLOG(1) << "Finalized with " << completions.size()
-          << " chosen completions";
-
-  for (vector<string>::const_iterator it = completions.begin();
-      it != completions.end();
-      ++it) {
-    DVLOG(9) << "  Completion entry: '" << *it << "'";
-    fprintf(stdout, "%s\n", it->c_str());
-  }
-}
-
-
-// 1) Examine search word (and helper method)
-static void CanonicalizeCursorWordAndSearchOptions(
-    const string &cursor_word,
-    string *canonical_search_token,
-    CompletionOptions *options) {
-  *canonical_search_token = cursor_word;
-  if (canonical_search_token->empty()) return;
-
-  // Get rid of leading quotes and dashes in the search term
-  if ((*canonical_search_token)[0] == '"')
-    *canonical_search_token = canonical_search_token->substr(1);
-  while ((*canonical_search_token)[0] == '-')
-    *canonical_search_token = canonical_search_token->substr(1);
-
-  options->flag_name_substring_search = false;
-  options->flag_location_substring_search = false;
-  options->flag_description_substring_search = false;
-  options->return_all_matching_flags = false;
-  options->force_no_update = false;
-
-  // Look for all search options we can deduce now.  Do this by walking
-  // backwards through the term, looking for up to three '?' and up to
-  // one '+' as suffixed characters.  Consume them if found, and remove
-  // them from the canonical search token.
-  int found_question_marks = 0;
-  int found_plusses = 0;
-  while (true) {
-    if (found_question_marks < 3 &&
-        RemoveTrailingChar(canonical_search_token, '?')) {
-      ++found_question_marks;
-      continue;
-    }
-    if (found_plusses < 1 &&
-        RemoveTrailingChar(canonical_search_token, '+')) {
-      ++found_plusses;
-      continue;
-    }
-    break;
-  }
-
-  switch (found_question_marks) {  // all fallthroughs
-    case 3: options->flag_description_substring_search = true;
-    case 2: options->flag_location_substring_search = true;
-    case 1: options->flag_name_substring_search = true;
-  };
-
-  options->return_all_matching_flags = (found_plusses > 0);
-}
-
-// Returns true if a char was removed
-static bool RemoveTrailingChar(string *str, char c) {
-  if (str->empty()) return false;
-  if ((*str)[str->size() - 1] == c) {
-    *str = str->substr(0, str->size() - 1);
-    return true;
-  }
-  return false;
-}
-
-
-// 2) Find all matches (and helper methods)
-static void FindMatchingFlags(
-    const vector<CommandLineFlagInfo> &all_flags,
-    const CompletionOptions &options,
-    const string &match_token,
-    set<const CommandLineFlagInfo *> *all_matches,
-    string *longest_common_prefix) {
-  all_matches->clear();
-  bool first_match = true;
-  for (vector<CommandLineFlagInfo>::const_iterator it = all_flags.begin();
-      it != all_flags.end();
-      ++it) {
-    if (DoesSingleFlagMatch(*it, options, match_token)) {
-      all_matches->insert(&*it);
-      if (first_match) {
-        first_match = false;
-        *longest_common_prefix = it->name;
-      } else {
-        if (longest_common_prefix->empty() || it->name.empty()) {
-          longest_common_prefix->clear();
-          continue;
-        }
-        string::size_type pos = 0;
-        while (pos < longest_common_prefix->size() &&
-            pos < it->name.size() &&
-            (*longest_common_prefix)[pos] == it->name[pos])
-          ++pos;
-        longest_common_prefix->erase(pos);
-      }
-    }
-  }
-}
-
-// Given the set of all flags, the parsed match options, and the
-// canonical search token, produce the set of all candidate matching
-// flags for subsequent analysis or filtering.
-static bool DoesSingleFlagMatch(
-    const CommandLineFlagInfo &flag,
-    const CompletionOptions &options,
-    const string &match_token) {
-  // Is there a prefix match?
-  string::size_type pos = flag.name.find(match_token);
-  if (pos == 0) return true;
-
-  // Is there a substring match if we want it?
-  if (options.flag_name_substring_search &&
-      pos != string::npos)
-    return true;
-
-  // Is there a location match if we want it?
-  if (options.flag_location_substring_search &&
-      flag.filename.find(match_token) != string::npos)
-    return true;
-
-  // TODO(user): All searches should probably be case-insensitive
-  // (especially this one...)
-  if (options.flag_description_substring_search &&
-      flag.description.find(match_token) != string::npos)
-    return true;
-
-  return false;
-}
-
-// 3) Categorize matches (and helper method)
-
-// Given a set of matching flags, categorize them by
-// likely relevence to this specific binary
-static void CategorizeAllMatchingFlags(
-    const set<const CommandLineFlagInfo *> &all_matches,
-    const string &search_token,
-    const string &module,  // empty if we couldn't find any
-    const string &package_dir,  // empty if we couldn't find any
-    NotableFlags *notable_flags) {
-  notable_flags->perfect_match_flag.clear();
-  notable_flags->module_flags.clear();
-  notable_flags->package_flags.clear();
-  notable_flags->most_common_flags.clear();
-  notable_flags->subpackage_flags.clear();
-
-  for (set<const CommandLineFlagInfo *>::const_iterator it =
-        all_matches.begin();
-      it != all_matches.end();
-      ++it) {
-    DVLOG(2) << "Examining match '" << (*it)->name << "'";
-    DVLOG(7) << "  filename: '" << (*it)->filename << "'";
-    string::size_type pos = string::npos;
-    if (!package_dir.empty())
-      pos = (*it)->filename.find(package_dir);
-    string::size_type slash = string::npos;
-    if (pos != string::npos)  // candidate for package or subpackage match
-      slash = (*it)->filename.find(
-          PATH_SEPARATOR,
-          pos + package_dir.size() + 1);
-
-    if ((*it)->name == search_token) {
-      // Exact match on some flag's name
-      notable_flags->perfect_match_flag.insert(*it);
-      DVLOG(3) << "Result: perfect match";
-    } else if (!module.empty() && (*it)->filename == module) {
-      // Exact match on module filename
-      notable_flags->module_flags.insert(*it);
-      DVLOG(3) << "Result: module match";
-    } else if (!package_dir.empty() &&
-        pos != string::npos && slash == string::npos) {
-      // In the package, since there was no slash after the package portion
-      notable_flags->package_flags.insert(*it);
-      DVLOG(3) << "Result: package match";
-    } else if (false) {
-      // In the list of the XXX most commonly supplied flags overall
-      // TODO(user): Compile this list.
-      DVLOG(3) << "Result: most-common match";
-    } else if (!package_dir.empty() &&
-        pos != string::npos && slash != string::npos) {
-      // In a subdirectory of the package
-      notable_flags->subpackage_flags.insert(*it);
-      DVLOG(3) << "Result: subpackage match";
-    }
-
-    DVLOG(3) << "Result: not special match";
-  }
-}
-
-static void PushNameWithSuffix(vector<string>* suffixes, const char* suffix) {
-  suffixes->push_back(
-      StringPrintf("/%s%s", ProgramInvocationShortName(), suffix));
-}
-
-static void TryFindModuleAndPackageDir(
-    const vector<CommandLineFlagInfo> all_flags,
-    string *module,
-    string *package_dir) {
-  module->clear();
-  package_dir->clear();
-
-  vector<string> suffixes;
-  // TODO(user): There's some inherant ambiguity here - multiple directories
-  // could share the same trailing folder and file structure (and even worse,
-  // same file names), causing us to be unsure as to which of the two is the
-  // actual package for this binary.  In this case, we'll arbitrarily choose.
-  PushNameWithSuffix(&suffixes, ".");
-  PushNameWithSuffix(&suffixes, "-main.");
-  PushNameWithSuffix(&suffixes, "_main.");
-  // These four are new but probably merited?
-  PushNameWithSuffix(&suffixes, "-test.");
-  PushNameWithSuffix(&suffixes, "_test.");
-  PushNameWithSuffix(&suffixes, "-unittest.");
-  PushNameWithSuffix(&suffixes, "_unittest.");
-
-  for (vector<CommandLineFlagInfo>::const_iterator it = all_flags.begin();
-      it != all_flags.end();
-      ++it) {
-    for (vector<string>::const_iterator suffix = suffixes.begin();
-        suffix != suffixes.end();
-        ++suffix) {
-      // TODO(user): Make sure the match is near the end of the string
-      if (it->filename.find(*suffix) != string::npos) {
-        *module = it->filename;
-        string::size_type sep = it->filename.rfind(PATH_SEPARATOR);
-        *package_dir = it->filename.substr(0, (sep == string::npos) ? 0 : sep);
-        return;
-      }
-    }
-  }
-}
-
-// Can't specialize template type on a locally defined type.  Silly C++...
-struct DisplayInfoGroup {
-  const char* header;
-  const char* footer;
-  set<const CommandLineFlagInfo *> *group;
-
-  int SizeInLines() const {
-    int size_in_lines = static_cast<int>(group->size()) + 1;
-    if (strlen(header) > 0) {
-      size_in_lines++;
-    }
-    if (strlen(footer) > 0) {
-      size_in_lines++;
-    }
-    return size_in_lines;
-  }
-};
-
-// 4) Finalize and trim output flag set
-static void FinalizeCompletionOutput(
-    const set<const CommandLineFlagInfo *> &matching_flags,
-    CompletionOptions *options,
-    NotableFlags *notable_flags,
-    vector<string> *completions) {
-
-  // We want to output lines in groups.  Each group needs to be indented
-  // the same to keep its lines together.  Unless otherwise required,
-  // only 99 lines should be output to prevent bash from harassing the
-  // user.
-
-  // First, figure out which output groups we'll actually use.  For each
-  // nonempty group, there will be ~3 lines of header & footer, plus all
-  // output lines themselves.
-  int max_desired_lines =  // "999999 flags should be enough for anyone.  -dave"
-    (options->return_all_matching_flags ? 999999 : 98);
-  int lines_so_far = 0;
-
-  vector<DisplayInfoGroup> output_groups;
-  bool perfect_match_found = false;
-  if (lines_so_far < max_desired_lines &&
-      !notable_flags->perfect_match_flag.empty()) {
-    perfect_match_found = true;
-    DisplayInfoGroup group =
-        { "",
-          "==========",
-          &notable_flags->perfect_match_flag };
-    lines_so_far += group.SizeInLines();
-    output_groups.push_back(group);
-  }
-  if (lines_so_far < max_desired_lines &&
-      !notable_flags->module_flags.empty()) {
-    DisplayInfoGroup group = {
-        "-* Matching module flags *-",
-        "===========================",
-        &notable_flags->module_flags };
-    lines_so_far += group.SizeInLines();
-    output_groups.push_back(group);
-  }
-  if (lines_so_far < max_desired_lines &&
-      !notable_flags->package_flags.empty()) {
-    DisplayInfoGroup group = {
-        "-* Matching package flags *-",
-        "============================",
-        &notable_flags->package_flags };
-    lines_so_far += group.SizeInLines();
-    output_groups.push_back(group);
-  }
-  if (lines_so_far < max_desired_lines &&
-      !notable_flags->most_common_flags.empty()) {
-    DisplayInfoGroup group = {
-        "-* Commonly used flags *-",
-        "=========================",
-        &notable_flags->most_common_flags };
-    lines_so_far += group.SizeInLines();
-    output_groups.push_back(group);
-  }
-  if (lines_so_far < max_desired_lines &&
-      !notable_flags->subpackage_flags.empty()) {
-    DisplayInfoGroup group = {
-        "-* Matching sub-package flags *-",
-        "================================",
-        &notable_flags->subpackage_flags };
-    lines_so_far += group.SizeInLines();
-    output_groups.push_back(group);
-  }
-
-  set<const CommandLineFlagInfo *> obscure_flags;  // flags not notable
-  if (lines_so_far < max_desired_lines) {
-    RetrieveUnusedFlags(matching_flags, *notable_flags, &obscure_flags);
-    if (!obscure_flags.empty()) {
-      DisplayInfoGroup group = {
-          "-* Other flags *-",
-          "",
-          &obscure_flags };
-      lines_so_far += group.SizeInLines();
-      output_groups.push_back(group);
-    }
-  }
-
-  // Second, go through each of the chosen output groups and output
-  // as many of those flags as we can, while remaining below our limit
-  int remaining_lines = max_desired_lines;
-  size_t completions_output = 0;
-  int indent = static_cast<int>(output_groups.size()) - 1;
-  for (vector<DisplayInfoGroup>::const_iterator it =
-        output_groups.begin();
-      it != output_groups.end();
-      ++it, --indent) {
-    OutputSingleGroupWithLimit(
-        *it->group,  // group
-        string(indent, ' '),  // line indentation
-        string(it->header),  // header
-        string(it->footer),  // footer
-        perfect_match_found,  // long format
-        &remaining_lines,  // line limit - reduces this by number printed
-        &completions_output,  // completions (not lines) added
-        completions);  // produced completions
-    perfect_match_found = false;
-  }
-
-  if (completions_output != matching_flags.size()) {
-    options->force_no_update = false;
-    completions->push_back("~ (Remaining flags hidden) ~");
-  } else {
-    options->force_no_update = true;
-  }
-}
-
-static void RetrieveUnusedFlags(
-    const set<const CommandLineFlagInfo *> &matching_flags,
-    const NotableFlags &notable_flags,
-    set<const CommandLineFlagInfo *> *unused_flags) {
-  // Remove from 'matching_flags' set all members of the sets of
-  // flags we've already printed (specifically, those in notable_flags)
-  for (set<const CommandLineFlagInfo *>::const_iterator it =
-        matching_flags.begin();
-      it != matching_flags.end();
-      ++it) {
-    if (notable_flags.perfect_match_flag.count(*it) ||
-        notable_flags.module_flags.count(*it) ||
-        notable_flags.package_flags.count(*it) ||
-        notable_flags.most_common_flags.count(*it) ||
-        notable_flags.subpackage_flags.count(*it))
-      continue;
-    unused_flags->insert(*it);
-  }
-}
-
-// 5) Output matches (and helper methods)
-
-static void OutputSingleGroupWithLimit(
-    const set<const CommandLineFlagInfo *> &group,
-    const string &line_indentation,
-    const string &header,
-    const string &footer,
-    bool long_output_format,
-    int *remaining_line_limit,
-    size_t *completion_elements_output,
-    vector<string> *completions) {
-  if (group.empty()) return;
-  if (!header.empty()) {
-    if (*remaining_line_limit < 2) return;
-    *remaining_line_limit -= 2;
-    completions->push_back(line_indentation + header);
-    completions->push_back(line_indentation + string(header.size(), '-'));
-  }
-  for (set<const CommandLineFlagInfo *>::const_iterator it = group.begin();
-      it != group.end() && *remaining_line_limit > 0;
-      ++it) {
-    --*remaining_line_limit;
-    ++*completion_elements_output;
-    completions->push_back(
-        (long_output_format
-          ? GetLongFlagLine(line_indentation, **it)
-          : GetShortFlagLine(line_indentation, **it)));
-  }
-  if (!footer.empty()) {
-    if (*remaining_line_limit < 1) return;
-    --*remaining_line_limit;
-    completions->push_back(line_indentation + footer);
-  }
-}
-
-static string GetShortFlagLine(
-    const string &line_indentation,
-    const CommandLineFlagInfo &info) {
-  string prefix;
-  bool is_string = (info.type == "string");
-  SStringPrintf(&prefix, "%s--%s [%s%s%s] ",
-                line_indentation.c_str(),
-                info.name.c_str(),
-                (is_string ? "'" : ""),
-                info.default_value.c_str(),
-                (is_string ? "'" : ""));
-  int remainder =
-      FLAGS_tab_completion_columns - static_cast<int>(prefix.size());
-  string suffix;
-  if (remainder > 0)
-    suffix =
-        (static_cast<int>(info.description.size()) > remainder ?
-         (info.description.substr(0, remainder - 3) + "...").c_str() :
-         info.description.c_str());
-  return prefix + suffix;
-}
-
-static string GetLongFlagLine(
-    const string &line_indentation,
-    const CommandLineFlagInfo &info) {
-
-  string output = DescribeOneFlag(info);
-
-  // Replace '-' with '--', and remove trailing newline before appending
-  // the module definition location.
-  string old_flagname = "-" + info.name;
-  output.replace(
-      output.find(old_flagname),
-      old_flagname.size(),
-      "-" + old_flagname);
-  // Stick a newline and indentation in front of the type and default
-  // portions of DescribeOneFlag()s description
-  static const char kNewlineWithIndent[] = "\n    ";
-  output.replace(output.find(" type:"), 1, string(kNewlineWithIndent));
-  output.replace(output.find(" default:"), 1, string(kNewlineWithIndent));
-  output = StringPrintf("%s Details for '--%s':\n"
-                        "%s    defined: %s",
-                        line_indentation.c_str(),
-                        info.name.c_str(),
-                        output.c_str(),
-                        info.filename.c_str());
-
-  // Eliminate any doubled newlines that crept in.  Specifically, if
-  // DescribeOneFlag() decided to break the line just before "type"
-  // or "default", we don't want to introduce an extra blank line
-  static const string line_of_spaces(FLAGS_tab_completion_columns, ' ');
-  static const char kDoubledNewlines[] = "\n     \n";
-  for (string::size_type newlines = output.find(kDoubledNewlines);
-      newlines != string::npos;
-      newlines = output.find(kDoubledNewlines))
-    // Replace each 'doubled newline' with a single newline
-    output.replace(newlines, sizeof(kDoubledNewlines) - 1, string("\n"));
-
-  for (string::size_type newline = output.find('\n');
-      newline != string::npos;
-      newline = output.find('\n')) {
-    int newline_pos = static_cast<int>(newline) % FLAGS_tab_completion_columns;
-    int missing_spaces = FLAGS_tab_completion_columns - newline_pos;
-    output.replace(newline, 1, line_of_spaces, 1, missing_spaces);
-  }
-  return output;
-}
-}  // anonymous
-
-void HandleCommandLineCompletions(void) {
-  if (FLAGS_tab_completion_word.empty()) return;
-  PrintFlagCompletionInfo();
-  gflags_exitfunc(0);
-}
-
-
-} // namespace GFLAGS_NAMESPACE

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/f8cf7fba/third_party/src/tmb/third_party/gflags/src/gflags_completions.h.in
----------------------------------------------------------------------
diff --git a/third_party/src/tmb/third_party/gflags/src/gflags_completions.h.in b/third_party/src/tmb/third_party/gflags/src/gflags_completions.h.in
deleted file mode 100644
index b27e5fd..0000000
--- a/third_party/src/tmb/third_party/gflags/src/gflags_completions.h.in
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright (c) 2008, 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.
-//
-// ---
-
-//
-// Implement helpful bash-style command line flag completions
-//
-// ** Functional API:
-// HandleCommandLineCompletions() should be called early during
-// program startup, but after command line flag code has been
-// initialized, such as the beginning of HandleCommandLineHelpFlags().
-// It checks the value of the flag --tab_completion_word.  If this
-// flag is empty, nothing happens here.  If it contains a string,
-// however, then HandleCommandLineCompletions() will hijack the
-// process, attempting to identify the intention behind this
-// completion.  Regardless of the outcome of this deduction, the
-// process will be terminated, similar to --helpshort flag
-// handling.
-//
-// ** Overview of Bash completions:
-// Bash can be told to programatically determine completions for the
-// current 'cursor word'.  It does this by (in this case) invoking a
-// command with some additional arguments identifying the command
-// being executed, the word being completed, and the previous word
-// (if any).  Bash then expects a sequence of output lines to be
-// printed to stdout.  If these lines all contain a common prefix
-// longer than the cursor word, bash will replace the cursor word
-// with that common prefix, and display nothing.  If there isn't such
-// a common prefix, bash will display the lines in pages using 'more'.
-//
-// ** Strategy taken for command line completions:
-// If we can deduce either the exact flag intended, or a common flag
-// prefix, we'll output exactly that.  Otherwise, if information
-// must be displayed to the user, we'll take the opportunity to add
-// some helpful information beyond just the flag name (specifically,
-// we'll include the default flag value and as much of the flag's
-// description as can fit on a single terminal line width, as specified
-// by the flag --tab_completion_columns).  Furthermore, we'll try to
-// make bash order the output such that the most useful or relevent
-// flags are the most likely to be shown at the top.
-//
-// ** Additional features:
-// To assist in finding that one really useful flag, substring matching
-// was implemented.  Before pressing a <TAB> to get completion for the
-// current word, you can append one or more '?' to the flag to do
-// substring matching.  Here's the semantics:
-//   --foo<TAB>     Show me all flags with names prefixed by 'foo'
-//   --foo?<TAB>    Show me all flags with 'foo' somewhere in the name
-//   --foo??<TAB>   Same as prior case, but also search in module
-//                  definition path for 'foo'
-//   --foo???<TAB>  Same as prior case, but also search in flag
-//                  descriptions for 'foo'
-// Finally, we'll trim the output to a relatively small number of
-// flags to keep bash quiet about the verbosity of output.  If one
-// really wanted to see all possible matches, appending a '+' to the
-// search word will force the exhaustive list of matches to be printed.
-//
-// ** How to have bash accept completions from a binary:
-// Bash requires that it be informed about each command that programmatic
-// completion should be enabled for.  Example addition to a .bashrc
-// file would be (your path to gflags_completions.sh file may differ):
-
-/*
-$ complete -o bashdefault -o default -o nospace -C                            \
- '/home/build/eng/bash/bash_completions.sh --tab_completion_columns $COLUMNS' \
-  time  env  binary_name  another_binary  [...]
-*/
-
-// This would allow the following to work:
-//   $ /path/to/binary_name --vmodule<TAB>
-// Or:
-//   $ ./bin/path/another_binary --gfs_u<TAB>
-// (etc)
-//
-// Sadly, it appears that bash gives no easy way to force this behavior for
-// all commands.  That's where the "time" in the above example comes in.
-// If you haven't specifically added a command to the list of completion
-// supported commands, you can still get completions by prefixing the
-// entire command with "env".
-//   $ env /some/brand/new/binary --vmod<TAB>
-// Assuming that "binary" is a newly compiled binary, this should still
-// produce the expected completion output.
-
-
-#ifndef GFLAGS_COMPLETIONS_H_
-#define GFLAGS_COMPLETIONS_H_
-
-namespace @GFLAGS_NAMESPACE@ {
-
-extern void HandleCommandLineCompletions(void);
-
-}
-
-#endif  // GFLAGS_COMPLETIONS_H_

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/f8cf7fba/third_party/src/tmb/third_party/gflags/src/gflags_completions.sh
----------------------------------------------------------------------
diff --git a/third_party/src/tmb/third_party/gflags/src/gflags_completions.sh b/third_party/src/tmb/third_party/gflags/src/gflags_completions.sh
deleted file mode 100755
index c5fb7e6..0000000
--- a/third_party/src/tmb/third_party/gflags/src/gflags_completions.sh
+++ /dev/null
@@ -1,117 +0,0 @@
-#!/bin/bash
-
-# Copyright (c) 2008, 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.
-#
-# ---
-# Author: Dave Nicponski
-#
-# This script is invoked by bash in response to a matching compspec.  When
-# this happens, bash calls this script using the command shown in the -C
-# block of the complete entry, but also appends 3 arguments.  They are:
-#   - The command being used for completion
-#   - The word being completed
-#   - The word preceding the completion word.
-#
-# Here's an example of how you might use this script:
-# $ complete -o bashdefault -o default -o nospace -C                         \
-#   '/usr/local/bin/gflags_completions.sh --tab_completion_columns $COLUMNS' \
-#   time  env  binary_name  another_binary  [...]
-
-# completion_word_index gets the index of the (N-1)th argument for
-# this command line.  completion_word gets the actual argument from
-# this command line at the (N-1)th position
-completion_word_index="$(($# - 1))"
-completion_word="${!completion_word_index}"
-
-# TODO(user): Replace this once gflags_completions.cc has
-# a bool parameter indicating unambiguously to hijack the process for
-# completion purposes.
-if [ -z "$completion_word" ]; then
-  # Until an empty value for the completion word stops being misunderstood
-  # by binaries, don't actually execute the binary or the process
-  # won't be hijacked!
-  exit 0
-fi
-
-# binary_index gets the index of the command being completed (which bash
-# places in the (N-2)nd position.  binary gets the actual command from
-# this command line at that (N-2)nd position
-binary_index="$(($# - 2))"
-binary="${!binary_index}"
-
-# For completions to be universal, we may have setup the compspec to
-# trigger on 'harmless pass-through' commands, like 'time' or 'env'.
-# If the command being completed is one of those two, we'll need to
-# identify the actual command being executed.  To do this, we need
-# the actual command line that the <TAB> was pressed on.  Bash helpfully
-# places this in the $COMP_LINE variable.
-if [ "$binary" == "time" ] || [ "$binary" == "env" ]; then
-  # we'll assume that the first 'argument' is actually the
-  # binary
-
-
-  # TODO(user): This is not perfect - the 'env' command, for instance,
-  #   is allowed to have options between the 'env' and 'the command to
-  #   be executed'.  For example, consider:
-  # $ env FOO="bar"  bin/do_something  --help<TAB>
-  # In this case, we'll mistake the FOO="bar" portion as the binary.
-  #   Perhaps we should continuing consuming leading words until we
-  #   either run out of words, or find a word that is a valid file
-  #   marked as executable.  I can't think of any reason this wouldn't
-  #   work.
-
-  # Break up the 'original command line' (not this script's command line,
-  # rather the one the <TAB> was pressed on) and find the second word.
-  parts=( ${COMP_LINE} )
-  binary=${parts[1]}
-fi
-
-# Build the command line to use for completion.  Basically it involves
-# passing through all the arguments given to this script (except the 3
-# that bash added), and appending a '--tab_completion_word "WORD"' to
-# the arguments.
-params=""
-for ((i=1; i<=$(($# - 3)); ++i)); do 
-  params="$params \"${!i}\"";
-done
-params="$params --tab_completion_word \"$completion_word\""
-
-# TODO(user): Perhaps stash the output in a temporary file somewhere
-# in /tmp, and only cat it to stdout if the command returned a success
-# code, to prevent false positives
-
-# If we think we have a reasonable command to execute, then execute it
-# and hope for the best.
-candidate=$(type -p "$binary")
-if [ ! -z "$candidate" ]; then
-  eval "$candidate 2>/dev/null $params"
-elif [ -f "$binary" ] && [ -x "$binary" ]; then
-  eval "$binary 2>/dev/null $params"
-fi

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/f8cf7fba/third_party/src/tmb/third_party/gflags/src/gflags_declare.h.in
----------------------------------------------------------------------
diff --git a/third_party/src/tmb/third_party/gflags/src/gflags_declare.h.in b/third_party/src/tmb/third_party/gflags/src/gflags_declare.h.in
deleted file mode 100644
index 279db24..0000000
--- a/third_party/src/tmb/third_party/gflags/src/gflags_declare.h.in
+++ /dev/null
@@ -1,141 +0,0 @@
-// Copyright (c) 1999, 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
-// command line flag.
-
-#ifndef GFLAGS_DECLARE_H_
-#define GFLAGS_DECLARE_H_
-
-
-// ---------------------------------------------------------------------------
-// Namespace of gflags library symbols.
-#define GFLAGS_NAMESPACE @GFLAGS_NAMESPACE@
-
-// ---------------------------------------------------------------------------
-// Windows DLL import/export.
-
-// We always want to import the symbols of the gflags library
-#ifndef GFLAGS_DLL_DECL
-#  if @GFLAGS_IS_A_DLL@ && defined(_MSC_VER)
-#    define GFLAGS_DLL_DECL __declspec(dllimport)
-#  else
-#    define GFLAGS_DLL_DECL
-#  endif
-#endif
-
-// We always want to import variables declared in user code
-#ifndef GFLAGS_DLL_DECLARE_FLAG
-#  ifdef _MSC_VER
-#    define GFLAGS_DLL_DECLARE_FLAG __declspec(dllimport)
-#  else
-#    define GFLAGS_DLL_DECLARE_FLAG
-#  endif
-#endif
-
-// ---------------------------------------------------------------------------
-// Flag types
-#include <string>
-#if @HAVE_STDINT_H@
-#  include <stdint.h>                   // the normal place uint32_t is defined
-#elif @HAVE_SYS_TYPES_H@
-#  include <sys/types.h>                // the normal place u_int32_t is defined
-#elif @HAVE_INTTYPES_H@
-#  include <inttypes.h>                 // a third place for uint32_t or u_int32_t
-#endif
-
-namespace GFLAGS_NAMESPACE {
-
-#if @GFLAGS_INTTYPES_FORMAT_C99@ // C99
-typedef int32_t          int32;
-typedef uint32_t         uint32;
-typedef int64_t          int64;
-typedef uint64_t         uint64;
-#elif @GFLAGS_INTTYPES_FORMAT_BSD@ // BSD
-typedef int32_t          int32;
-typedef u_int32_t        uint32;
-typedef int64_t          int64;
-typedef u_int64_t        uint64;
-#elif @GFLAGS_INTTYPES_FORMAT_VC7@ // Windows
-typedef __int32          int32;
-typedef unsigned __int32 uint32;
-typedef __int64          int64;
-typedef unsigned __int64 uint64;
-#else
-#  error Do not know how to define a 32-bit integer quantity on your system
-#endif
-
-} // namespace GFLAGS_NAMESPACE
-
-
-namespace fLS {
-
-// The meaning of "string" might be different between now and when the
-// macros below get invoked (e.g., if someone is experimenting with
-// other string implementations that get defined after this file is
-// included).  Save the current meaning now and use it in the macros.
-typedef std::string clstring;
-
-} // namespace fLS
-
-
-#define DECLARE_VARIABLE(type, shorttype, name) \
-  /* We always want to import declared variables, dll or no */ \
-  namespace fL##shorttype { extern GFLAGS_DLL_DECLARE_FLAG type FLAGS_##name; } \
-  using fL##shorttype::FLAGS_##name
-
-#define DECLARE_bool(name) \
-  DECLARE_VARIABLE(bool, B, name)
-
-#define DECLARE_int32(name) \
-  DECLARE_VARIABLE(::GFLAGS_NAMESPACE::int32, I, name)
-
-#define DECLARE_int64(name) \
-  DECLARE_VARIABLE(::GFLAGS_NAMESPACE::int64, I64, name)
-
-#define DECLARE_uint64(name) \
-  DECLARE_VARIABLE(::GFLAGS_NAMESPACE::uint64, U64, name)
-
-#define DECLARE_double(name) \
-  DECLARE_VARIABLE(double, D, name)
-
-#define DECLARE_string(name) \
-  /* We always want to import declared variables, dll or no */ \
-  namespace fLS { \
-  using ::fLS::clstring; \
-  extern GFLAGS_DLL_DECLARE_FLAG ::fLS::clstring& FLAGS_##name; \
-  } \
-  using fLS::FLAGS_##name
-
-
-#endif  // GFLAGS_DECLARE_H_

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/f8cf7fba/third_party/src/tmb/third_party/gflags/src/gflags_ns.h.in
----------------------------------------------------------------------
diff --git a/third_party/src/tmb/third_party/gflags/src/gflags_ns.h.in b/third_party/src/tmb/third_party/gflags/src/gflags_ns.h.in
deleted file mode 100644
index f692666..0000000
--- a/third_party/src/tmb/third_party/gflags/src/gflags_ns.h.in
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright (c) 2014, Andreas Schuh
-// 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.
-
-// -----------------------------------------------------------------------------
-// Imports the gflags library symbols into an alternative/deprecated namespace.
-
-#ifndef GFLAGS_GFLAGS_H_
-#  error The internal header gflags_@ns@.h may only be included by gflags.h
-#endif
-
-#ifndef GFLAGS_NS_@NS@_H_
-#define GFLAGS_NS_@NS@_H_
-
-
-namespace @ns@ {
-
-
-using GFLAGS_NAMESPACE::int32;
-using GFLAGS_NAMESPACE::uint32;
-using GFLAGS_NAMESPACE::int64;
-using GFLAGS_NAMESPACE::uint64;
-
-using GFLAGS_NAMESPACE::RegisterFlagValidator;
-using GFLAGS_NAMESPACE::CommandLineFlagInfo;
-using GFLAGS_NAMESPACE::GetAllFlags;
-using GFLAGS_NAMESPACE::ShowUsageWithFlags;
-using GFLAGS_NAMESPACE::ShowUsageWithFlagsRestrict;
-using GFLAGS_NAMESPACE::DescribeOneFlag;
-using GFLAGS_NAMESPACE::SetArgv;
-using GFLAGS_NAMESPACE::GetArgvs;
-using GFLAGS_NAMESPACE::GetArgv;
-using GFLAGS_NAMESPACE::GetArgv0;
-using GFLAGS_NAMESPACE::GetArgvSum;
-using GFLAGS_NAMESPACE::ProgramInvocationName;
-using GFLAGS_NAMESPACE::ProgramInvocationShortName;
-using GFLAGS_NAMESPACE::ProgramUsage;
-using GFLAGS_NAMESPACE::VersionString;
-using GFLAGS_NAMESPACE::GetCommandLineOption;
-using GFLAGS_NAMESPACE::GetCommandLineFlagInfo;
-using GFLAGS_NAMESPACE::GetCommandLineFlagInfoOrDie;
-using GFLAGS_NAMESPACE::FlagSettingMode;
-using GFLAGS_NAMESPACE::SET_FLAGS_VALUE;
-using GFLAGS_NAMESPACE::SET_FLAG_IF_DEFAULT;
-using GFLAGS_NAMESPACE::SET_FLAGS_DEFAULT;
-using GFLAGS_NAMESPACE::SetCommandLineOption;
-using GFLAGS_NAMESPACE::SetCommandLineOptionWithMode;
-using GFLAGS_NAMESPACE::FlagSaver;
-using GFLAGS_NAMESPACE::CommandlineFlagsIntoString;
-using GFLAGS_NAMESPACE::ReadFlagsFromString;
-using GFLAGS_NAMESPACE::AppendFlagsIntoFile;
-using GFLAGS_NAMESPACE::ReadFromFlagsFile;
-using GFLAGS_NAMESPACE::BoolFromEnv;
-using GFLAGS_NAMESPACE::Int32FromEnv;
-using GFLAGS_NAMESPACE::Int64FromEnv;
-using GFLAGS_NAMESPACE::Uint64FromEnv;
-using GFLAGS_NAMESPACE::DoubleFromEnv;
-using GFLAGS_NAMESPACE::StringFromEnv;
-using GFLAGS_NAMESPACE::SetUsageMessage;
-using GFLAGS_NAMESPACE::SetVersionString;
-using GFLAGS_NAMESPACE::ParseCommandLineNonHelpFlags;
-using GFLAGS_NAMESPACE::HandleCommandLineHelpFlags;
-using GFLAGS_NAMESPACE::AllowCommandLineReparsing;
-using GFLAGS_NAMESPACE::ReparseCommandLineNonHelpFlags;
-using GFLAGS_NAMESPACE::ShutDownCommandLineFlags;
-using GFLAGS_NAMESPACE::FlagRegisterer;
-
-#ifndef SWIG
-using GFLAGS_NAMESPACE::ParseCommandLineFlags;
-#endif
-
-
-} // namespace @ns@
-
-
-#endif  // GFLAGS_NS_@NS@_H_


Mime
View raw message