quickstep-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From zu...@apache.org
Subject [38/53] [partial] incubator-quickstep git commit: Make the third party directory leaner.
Date Sun, 29 Jan 2017 02:15:48 GMT
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/9661f956/third_party/glog/doc/designstyle.css
----------------------------------------------------------------------
diff --git a/third_party/glog/doc/designstyle.css b/third_party/glog/doc/designstyle.css
deleted file mode 100644
index f5d1ec2..0000000
--- a/third_party/glog/doc/designstyle.css
+++ /dev/null
@@ -1,115 +0,0 @@
-body {
-  background-color: #ffffff;
-  color: black;
-  margin-right: 1in;
-  margin-left: 1in;
-}
-
-
-h1, h2, h3, h4, h5, h6 {
-  color: #3366ff;
-  font-family: sans-serif;
-}
-@media print {
-  /* Darker version for printing */
-  h1, h2, h3, h4, h5, h6 {
-    color: #000080;
-    font-family: helvetica, sans-serif;
-  }
-}
-
-h1 { 
-  text-align: center;
-  font-size: 18pt;
-}
-h2 {
-  margin-left: -0.5in;
-}
-h3 {
-  margin-left: -0.25in;
-}
-h4 {
-  margin-left: -0.125in;
-}
-hr {
-  margin-left: -1in;
-}
-
-/* Definition lists: definition term bold */
-dt {
-  font-weight: bold;
-}
-
-address {
-  text-align: right;
-}
-/* Use the <code> tag for bits of code and <var> for variables and objects. */
-code,pre,samp,var {
-  color: #006000;
-}
-/* Use the <file> tag for file and directory paths and names. */
-file {
-  color: #905050;
-  font-family: monospace;
-}
-/* Use the <kbd> tag for stuff the user should type. */
-kbd {
-  color: #600000;
-}
-div.note p {
-  float: right;
-  width: 3in;
-  margin-right: 0%;
-  padding: 1px;
-  border: 2px solid #6060a0;
-  background-color: #fffff0;
-}
-
-UL.nobullets {
-  list-style-type: none;
-  list-style-image: none;
-  margin-left: -1em;
-}
-
-/*
-body:after {
-  content: "Google Confidential";
-}
-*/
-
-/* pretty printing styles.  See prettify.js */
-.str { color: #080; }
-.kwd { color: #008; }
-.com { color: #800; }
-.typ { color: #606; }
-.lit { color: #066; }
-.pun { color: #660; }
-.pln { color: #000; }
-.tag { color: #008; }
-.atn { color: #606; }
-.atv { color: #080; }
-pre.prettyprint { padding: 2px; border: 1px solid #888; }
-
-.embsrc { background: #eee; }
-
-@media print {
-  .str { color: #060; }
-  .kwd { color: #006; font-weight: bold; }
-  .com { color: #600; font-style: italic; }
-  .typ { color: #404; font-weight: bold; }
-  .lit { color: #044; }
-  .pun { color: #440; }
-  .pln { color: #000; }
-  .tag { color: #006; font-weight: bold; }
-  .atn { color: #404; }
-  .atv { color: #060; }
-}
-
-/* Table Column Headers */
-.hdr { 
-  color: #006; 
-  font-weight: bold; 
-  background-color: #dddddd; }
-.hdr2 { 
-  color: #006; 
-  background-color: #eeeeee; }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/9661f956/third_party/glog/doc/glog.html
----------------------------------------------------------------------
diff --git a/third_party/glog/doc/glog.html b/third_party/glog/doc/glog.html
deleted file mode 100644
index 8b200ba..0000000
--- a/third_party/glog/doc/glog.html
+++ /dev/null
@@ -1,613 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
-
-<html>
-<head>
-<title>How To Use Google Logging Library (glog)</title>
-
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<link href="http://www.google.com/favicon.ico" type="image/x-icon"
-      rel="shortcut icon">
-<link href="designstyle.css" type="text/css" rel="stylesheet">
-<style type="text/css">
-<!--
-  ol.bluelist li {
-    color: #3366ff;
-    font-family: sans-serif;
-  }
-  ol.bluelist li p {
-    color: #000;
-    font-family: "Times Roman", times, serif;
-  }
-  ul.blacklist li {
-    color: #000;
-    font-family: "Times Roman", times, serif;
-  }
-//-->
-</style>
-</head>
-
-<body>
-
-<h1>How To Use Google Logging Library (glog)</h1>
-<small>(as of
-<script type=text/javascript>
-  var lm = new Date(document.lastModified);
-  document.write(lm.toDateString());
-</script>)
-</small>
-<br>
-
-<h2> <A NAME=intro>Introduction</A> </h2>
-
-<p><b>Google glog</b> is a library that implements application-level
-logging.  This library provides logging APIs based on C++-style
-streams and various helper macros.
-You can log a message by simply streaming things to LOG(&lt;a
-particular <a href="#severity">severity level</a>&gt;), e.g.
-
-<pre>
-   #include &lt;glog/logging.h&gt;
-
-   int main(int argc, char* argv[]) {
-     // Initialize Google's logging library.
-     google::InitGoogleLogging(argv[0]);
-
-     // ...
-     LOG(INFO) &lt;&lt; "Found " &lt;&lt; num_cookies &lt;&lt; " cookies";
-   }
-</pre>
-
-<p>Google glog defines a series of macros that simplify many common logging
-tasks.  You can log messages by severity level, control logging
-behavior from the command line, log based on conditionals, abort the
-program when expected conditions are not met, introduce your own
-verbose logging levels, and more.  This document describes the
-functionality supported by glog.  Please note that this document
-doesn't describe all features in this library, but the most useful
-ones.  If you want to find less common features, please check
-header files under <code>src/glog</code> directory.
-
-<h2> <A NAME=severity>Severity Level</A> </h2>
-
-<p>
-You can specify one of the following severity levels (in
-increasing order of severity): <code>INFO</code>, <code>WARNING</code>,
-<code>ERROR</code>, and <code>FATAL</code>.
-Logging a <code>FATAL</code> message terminates the program (after the
-message is logged).
-Note that messages of a given severity are logged not only in the
-logfile for that severity, but also in all logfiles of lower severity.
-E.g., a message of severity <code>FATAL</code> will be logged to the
-logfiles of severity <code>FATAL</code>, <code>ERROR</code>,
-<code>WARNING</code>, and <code>INFO</code>.
-
-<p>
-The <code>DFATAL</code> severity logs a <code>FATAL</code> error in
-debug mode (i.e., there is no <code>NDEBUG</code> macro defined), but
-avoids halting the program in production by automatically reducing the
-severity to <code>ERROR</code>.
-
-<p>Unless otherwise specified, glog writes to the filename
-"/tmp/&lt;program name&gt;.&lt;hostname&gt;.&lt;user name&gt;.log.&lt;severity level&gt;.&lt;date&gt;.&lt;time&gt;.&lt;pid&gt;"
-(e.g., "/tmp/hello_world.example.com.hamaji.log.INFO.20080709-222411.10474").
-By default, glog copies the log messages of severity level
-<code>ERROR</code> or <code>FATAL</code> to standard error (stderr)
-in addition to log files.
-
-<h2><A NAME=flags>Setting Flags</A></h2>
-
-<p>Several flags influence glog's output behavior.
-If the <a href="http://code.google.com/p/google-gflags/">Google
-gflags library</a> is installed on your machine, the
-<code>configure</code> script (see the INSTALL file in the package for
-detail of this script) will automatically detect and use it,
-allowing you to pass flags on the command line.  For example, if you
-want to turn the flag <code>--logtostderr</code> on, you can start
-your application with the following command line:
-
-<pre>
-   ./your_application --logtostderr=1
-</pre>
-
-If the Google gflags library isn't installed, you set flags via
-environment variables, prefixing the flag name with "GLOG_", e.g.
-
-<pre>
-   GLOG_logtostderr=1 ./your_application
-</pre>
-
-<!-- TODO(hamaji): Fill the version number
-<p>By glog version 0.x.x, you can use GLOG_* environment variables
-even if you have gflags. If both an environment variable and a flag
-are specified, the value specified by a flag wins. E.g., if GLOG_v=0
-and --v=1, the verbosity will be 1, not 0.
--->
-
-<p>The following flags are most commonly used:
-
-<dl>
-<dt><code>logtostderr</code> (<code>bool</code>, default=<code>false</code>)
-<dd>Log messages to stderr instead of logfiles.<br>
-Note: you can set binary flags to <code>true</code> by specifying
-<code>1</code>, <code>true</code>, or <code>yes</code> (case
-insensitive).
-Also, you can set binary flags to <code>false</code> by specifying
-<code>0</code>, <code>false</code>, or <code>no</code> (again, case
-insensitive).
-<dt><code>stderrthreshold</code> (<code>int</code>, default=2, which
-is <code>ERROR</code>)
-<dd>Copy log messages at or above this level to stderr in
-addition to logfiles.  The numbers of severity levels
-<code>INFO</code>, <code>WARNING</code>, <code>ERROR</code>, and
-<code>FATAL</code> are 0, 1, 2, and 3, respectively.
-<dt><code>minloglevel</code> (<code>int</code>, default=0, which
-is <code>INFO</code>)
-<dd>Log messages at or above this level.  Again, the numbers of
-severity levels <code>INFO</code>, <code>WARNING</code>,
-<code>ERROR</code>, and <code>FATAL</code> are 0, 1, 2, and 3,
-respectively.
-<dt><code>log_dir</code> (<code>string</code>, default="")
-<dd>If specified, logfiles are written into this directory instead
-of the default logging directory.
-<dt><code>v</code> (<code>int</code>, default=0)
-<dd>Show all <code>VLOG(m)</code> messages for <code>m</code> less or
-equal the value of this flag.  Overridable by --vmodule.
-See <a href="#verbose">the section about verbose logging</a> for more
-detail.
-<dt><code>vmodule</code> (<code>string</code>, default="")
-<dd>Per-module verbose level.  The argument has to contain a
-comma-separated list of &lt;module name&gt;=&lt;log level&gt;.
-&lt;module name&gt;
-is a glob pattern (e.g., <code>gfs*</code> for all modules whose name
-starts with "gfs"), matched against the filename base
-(that is, name ignoring .cc/.h./-inl.h).
-&lt;log level&gt; overrides any value given by --v.
-See also <a href="#verbose">the section about verbose logging</a>.
-</dl>
-
-<p>There are some other flags defined in logging.cc.  Please grep the
-source code for "DEFINE_" to see a complete list of all flags.
-
-<p>You can also modify flag values in your program by modifying global
-variables <code>FLAGS_*</code> . Most settings start working
-immediately after you update <code>FLAGS_*</code> . The exceptions are
-the flags related to destination files. For example, you might want to
-set <code>FLAGS_log_dir</code> before
-calling <code>google::InitGoogleLogging</code> . Here is an example:
-
-<pre>
-   LOG(INFO) << "file";
-   // Most flags work immediately after updating values.
-   FLAGS_logtostderr = 1;
-   LOG(INFO) << "stderr";
-   FLAGS_logtostderr = 0;
-   // This won't change the log destination. If you want to set this
-   // value, you should do this before google::InitGoogleLogging .
-   FLAGS_log_dir = "/some/log/directory";
-   LOG(INFO) << "the same file";
-</pre>
-
-<h2><A NAME=conditional>Conditional / Occasional Logging</A></h2>
-
-<p>Sometimes, you may only want to log a message under certain
-conditions. You can use the following macros to perform conditional
-logging:
-
-<pre>
-   LOG_IF(INFO, num_cookies &gt; 10) &lt;&lt; "Got lots of cookies";
-</pre>
-
-The "Got lots of cookies" message is logged only when the variable
-<code>num_cookies</code> exceeds 10.
-
-If a line of code is executed many times, it may be useful to only log
-a message at certain intervals.  This kind of logging is most useful
-for informational messages.
-
-<pre>
-   LOG_EVERY_N(INFO, 10) &lt;&lt; "Got the " &lt;&lt; google::COUNTER &lt;&lt; "th cookie";
-</pre>
-
-<p>The above line outputs a log messages on the 1st, 11th,
-21st, ... times it is executed.  Note that the special
-<code>google::COUNTER</code> value is used to identify which repetition is
-happening.
-
-<p>You can combine conditional and occasional logging with the
-following macro.
-
-<pre>
-   LOG_IF_EVERY_N(INFO, (size &gt; 1024), 10) &lt;&lt; "Got the " &lt;&lt; google::COUNTER
-                                           &lt;&lt; "th big cookie";
-</pre>
-
-<p>Instead of outputting a message every nth time, you can also limit
-the output to the first n occurrences:
-
-<pre>
-   LOG_FIRST_N(INFO, 20) &lt;&lt; "Got the " &lt;&lt; google::COUNTER &lt;&lt; "th cookie";
-</pre>
-
-<p>Outputs log messages for the first 20 times it is executed.  Again,
-the <code>google::COUNTER</code> identifier indicates which repetition is
-happening.
-
-<h2><A NAME=debug>Debug Mode Support</A></h2>
-
-<p>Special "debug mode" logging macros only have an effect in debug
-mode and are compiled away to nothing for non-debug mode
-compiles.  Use these macros to avoid slowing down your production
-application due to excessive logging.
-
-<pre>
-   DLOG(INFO) &lt;&lt; "Found cookies";
-
-   DLOG_IF(INFO, num_cookies &gt; 10) &lt;&lt; "Got lots of cookies";
-
-   DLOG_EVERY_N(INFO, 10) &lt;&lt; "Got the " &lt;&lt; google::COUNTER &lt;&lt; "th cookie";
-</pre>
-
-<h2><A NAME=check>CHECK Macros</A></h2>
-
-<p>It is a good practice to check expected conditions in your program
-frequently to detect errors as early as possible. The
-<code>CHECK</code> macro provides the ability to abort the application
-when a condition is not met, similar to the <code>assert</code> macro
-defined in the standard C library.
-
-<p><code>CHECK</code> aborts the application if a condition is not
-true.  Unlike <code>assert</code>, it is *not* controlled by
-<code>NDEBUG</code>, so the check will be executed regardless of
-compilation mode.  Therefore, <code>fp-&gt;Write(x)</code> in the
-following example is always executed:
-
-<pre>
-   CHECK(fp-&gt;Write(x) == 4) &lt;&lt; "Write failed!";
-</pre>
-
-<p>There are various helper macros for
-equality/inequality checks - <code>CHECK_EQ</code>,
-<code>CHECK_NE</code>, <code>CHECK_LE</code>, <code>CHECK_LT</code>,
-<code>CHECK_GE</code>, and <code>CHECK_GT</code>.
-They compare two values, and log a
-<code>FATAL</code> message including the two values when the result is
-not as expected.  The values must have <code>operator&lt;&lt;(ostream,
-...)</code> defined.
-
-<p>You may append to the error message like so:
-
-<pre>
-   CHECK_NE(1, 2) &lt;&lt; ": The world must be ending!";
-</pre>
-
-<p>We are very careful to ensure that each argument is evaluated exactly
-once, and that anything which is legal to pass as a function argument is
-legal here.  In particular, the arguments may be temporary expressions
-which will end up being destroyed at the end of the apparent statement,
-for example:
-
-<pre>
-   CHECK_EQ(string("abc")[1], 'b');
-</pre>
-
-<p>The compiler reports an error if one of the arguments is a
-pointer and the other is NULL. To work around this, simply static_cast
-NULL to the type of the desired pointer.
-
-<pre>
-   CHECK_EQ(some_ptr, static_cast&lt;SomeType*&gt;(NULL));
-</pre>
-
-<p>Better yet, use the CHECK_NOTNULL macro:
-
-<pre>
-   CHECK_NOTNULL(some_ptr);
-   some_ptr-&gt;DoSomething();
-</pre>
-
-<p>Since this macro returns the given pointer, this is very useful in
-constructor initializer lists.
-
-<pre>
-   struct S {
-     S(Something* ptr) : ptr_(CHECK_NOTNULL(ptr)) {}
-     Something* ptr_;
-   };
-</pre>
-
-<p>Note that you cannot use this macro as a C++ stream due to this
-feature.  Please use <code>CHECK_EQ</code> described above to log a
-custom message before aborting the application.
-
-<p>If you are comparing C strings (char *), a handy set of macros
-performs case sensitive as well as case insensitive comparisons -
-<code>CHECK_STREQ</code>, <code>CHECK_STRNE</code>,
-<code>CHECK_STRCASEEQ</code>, and <code>CHECK_STRCASENE</code>.  The
-CASE versions are case-insensitive.  You can safely pass <code>NULL</code>
-pointers for this macro.  They treat <code>NULL</code> and any
-non-<code>NULL</code> string as not equal.  Two <code>NULL</code>s are
-equal.
-
-<p>Note that both arguments may be temporary strings which are
-destructed at the end of the current "full expression"
-(e.g., <code>CHECK_STREQ(Foo().c_str(), Bar().c_str())</code> where
-<code>Foo</code> and <code>Bar</code> return C++'s
-<code>std::string</code>).
-
-<p>The <code>CHECK_DOUBLE_EQ</code> macro checks the equality of two
-floating point values, accepting a small error margin.
-<code>CHECK_NEAR</code> accepts a third floating point argument, which
-specifies the acceptable error margin.
-
-<h2><A NAME=verbose>Verbose Logging</A></h2>
-
-<p>When you are chasing difficult bugs, thorough log messages are very
-useful.  However, you may want to ignore too verbose messages in usual
-development.  For such verbose logging, glog provides the
-<code>VLOG</code> macro, which allows you to define your own numeric
-logging levels.  The <code>--v</code> command line option controls
-which verbose messages are logged:
-
-<pre>
-   VLOG(1) &lt;&lt; "I'm printed when you run the program with --v=1 or higher";
-   VLOG(2) &lt;&lt; "I'm printed when you run the program with --v=2 or higher";
-</pre>
-
-<p>With <code>VLOG</code>, the lower the verbose level, the more
-likely messages are to be logged.  For example, if
-<code>--v==1</code>, <code>VLOG(1)</code> will log, but
-<code>VLOG(2)</code> will not log.  This is opposite of the severity
-level, where <code>INFO</code> is 0, and <code>ERROR</code> is 2.
-<code>--minloglevel</code> of 1 will log <code>WARNING</code> and
-above.  Though you can specify any integers for both <code>VLOG</code>
-macro and <code>--v</code> flag, the common values for them are small
-positive integers.  For example, if you write <code>VLOG(0)</code>,
-you should specify <code>--v=-1</code> or lower to silence it.  This
-is less useful since we may not want verbose logs by default in most
-cases.  The <code>VLOG</code> macros always log at the
-<code>INFO</code> log level (when they log at all).
-
-<p>Verbose logging can be controlled from the command line on a
-per-module basis:
-
-<pre>
-   --vmodule=mapreduce=2,file=1,gfs*=3 --v=0
-</pre>
-
-<p>will:
-
-<ul>
-  <li>a. Print VLOG(2) and lower messages from mapreduce.{h,cc}
-  <li>b. Print VLOG(1) and lower messages from file.{h,cc}
-  <li>c. Print VLOG(3) and lower messages from files prefixed with "gfs"
-  <li>d. Print VLOG(0) and lower messages from elsewhere
-</ul>
-
-<p>The wildcarding functionality shown by (c) supports both '*'
-(matches 0 or more characters) and '?' (matches any single character)
-wildcards.  Please also check the section about <a
-href="#flags">command line flags</a>.
-
-<p>There's also <code>VLOG_IS_ON(n)</code> "verbose level" condition
-macro.  This macro returns true when the <code>--v</code> is equal or
-greater than <code>n</code>.  To be used as
-
-<pre>
-   if (VLOG_IS_ON(2)) {
-     // do some logging preparation and logging
-     // that can't be accomplished with just VLOG(2) &lt;&lt; ...;
-   }
-</pre>
-
-<p>Verbose level condition macros <code>VLOG_IF</code>,
-<code>VLOG_EVERY_N</code> and <code>VLOG_IF_EVERY_N</code> behave
-analogous to <code>LOG_IF</code>, <code>LOG_EVERY_N</code>,
-<code>LOF_IF_EVERY</code>, but accept a numeric verbosity level as
-opposed to a severity level.
-
-<pre>
-   VLOG_IF(1, (size &gt; 1024))
-      &lt;&lt; "I'm printed when size is more than 1024 and when you run the "
-         "program with --v=1 or more";
-   VLOG_EVERY_N(1, 10)
-      &lt;&lt; "I'm printed every 10th occurrence, and when you run the program "
-         "with --v=1 or more. Present occurence is " &lt;&lt; google::COUNTER;
-   VLOG_IF_EVERY_N(1, (size &gt; 1024), 10)
-      &lt;&lt; "I'm printed on every 10th occurence of case when size is more "
-         " than 1024, when you run the program with --v=1 or more. ";
-         "Present occurence is " &lt;&lt; google::COUNTER;
-</pre>
-
-<h2> <A name="signal">Failure Signal Handler</A> </h2>
-
-<p>
-The library provides a convenient signal handler that will dump useful
-information when the program crashes on certain signals such as SIGSEGV.
-The signal handler can be installed by
-google::InstallFailureSignalHandler().  The following is an example of output
-from the signal handler.
-
-<pre>
-*** Aborted at 1225095260 (unix time) try "date -d @1225095260" if you are using GNU date ***
-*** SIGSEGV (@0x0) received by PID 17711 (TID 0x7f893090a6f0) from PID 0; stack trace: ***
-PC: @           0x412eb1 TestWaitingLogSink::send()
-    @     0x7f892fb417d0 (unknown)
-    @           0x412eb1 TestWaitingLogSink::send()
-    @     0x7f89304f7f06 google::LogMessage::SendToLog()
-    @     0x7f89304f35af google::LogMessage::Flush()
-    @     0x7f89304f3739 google::LogMessage::~LogMessage()
-    @           0x408cf4 TestLogSinkWaitTillSent()
-    @           0x4115de main
-    @     0x7f892f7ef1c4 (unknown)
-    @           0x4046f9 (unknown)
-</pre>
-
-<p>
-By default, the signal handler writes the failure dump to the standard
-error.  You can customize the destination by InstallFailureWriter().
-
-<h2> <A name="misc">Miscellaneous Notes</A> </h2>
-
-<h3><A NAME=message>Performance of Messages</A></h3>
-
-<p>The conditional logging macros provided by glog (e.g.,
-<code>CHECK</code>, <code>LOG_IF</code>, <code>VLOG</code>, ...) are
-carefully implemented and don't execute the right hand side
-expressions when the conditions are false.  So, the following check
-may not sacrifice the performance of your application.
-
-<pre>
-   CHECK(obj.ok) &lt;&lt; obj.CreatePrettyFormattedStringButVerySlow();
-</pre>
-
-<h3><A NAME=failure>User-defined Failure Function</A></h3>
-
-<p><code>FATAL</code> severity level messages or unsatisfied
-<code>CHECK</code> condition terminate your program.  You can change
-the behavior of the termination by
-<code>InstallFailureFunction</code>.
-
-<pre>
-   void YourFailureFunction() {
-     // Reports something...
-     exit(1);
-   }
-
-   int main(int argc, char* argv[]) {
-     google::InstallFailureFunction(&amp;YourFailureFunction);
-   }
-</pre>
-
-<p>By default, glog tries to dump stacktrace and makes the program
-exit with status 1.  The stacktrace is produced only when you run the
-program on an architecture for which glog supports stack tracing (as
-of September 2008, glog supports stack tracing for x86 and x86_64).
-
-<h3><A NAME=raw>Raw Logging</A></h3>
-
-<p>The header file <code>&lt;glog/raw_logging.h&gt;</code> can be
-used for thread-safe logging, which does not allocate any memory or
-acquire any locks.  Therefore, the macros defined in this
-header file can be used by low-level memory allocation and
-synchronization code.
-Please check <code>src/glog/raw_logging.h.in</code> for detail.
-</p>
-
-<h3><A NAME=plog>Google Style perror()</A></h3>
-
-<p><code>PLOG()</code> and <code>PLOG_IF()</code> and
-<code>PCHECK()</code> behave exactly like their <code>LOG*</code> and
-<code>CHECK</code> equivalents with the addition that they append a
-description of the current state of errno to their output lines.
-E.g.
-
-<pre>
-   PCHECK(write(1, NULL, 2) &gt;= 0) &lt;&lt; "Write NULL failed";
-</pre>
-
-<p>This check fails with the following error message.
-
-<pre>
-   F0825 185142 test.cc:22] Check failed: write(1, NULL, 2) &gt;= 0 Write NULL failed: Bad address [14]
-</pre>
-
-<h3><A NAME=syslog>Syslog</A></h3>
-
-<p><code>SYSLOG</code>, <code>SYSLOG_IF</code>, and
-<code>SYSLOG_EVERY_N</code> macros are available.
-These log to syslog in addition to the normal logs.  Be aware that
-logging to syslog can drastically impact performance, especially if
-syslog is configured for remote logging!  Make sure you understand the
-implications of outputting to syslog before you use these macros. In
-general, it's wise to use these macros sparingly.
-
-<h3><A NAME=strip>Strip Logging Messages</A></h3>
-
-<p>Strings used in log messages can increase the size of your binary
-and present a privacy concern.  You can therefore instruct glog to
-remove all strings which fall below a certain severity level by using
-the GOOGLE_STRIP_LOG macro:
-
-<p>If your application has code like this:
-
-<pre>
-   #define GOOGLE_STRIP_LOG 1    // this must go before the #include!
-   #include &lt;glog/logging.h&gt;
-</pre>
-
-<p>The compiler will remove the log messages whose severities are less
-than the specified integer value.  Since
-<code>VLOG</code> logs at the severity level <code>INFO</code>
-(numeric value <code>0</code>),
-setting <code>GOOGLE_STRIP_LOG</code> to 1 or greater removes
-all log messages associated with <code>VLOG</code>s as well as
-<code>INFO</code> log statements.
-
-<h3><A NAME=windows>Notes for Windows users</A></h3>
-
-<p>Google glog defines a severity level <code>ERROR</code>, which is
-also defined in <code>windows.h</code> . You can make glog not define
-<code>INFO</code>, <code>WARNING</code>, <code>ERROR</code>,
-and <code>FATAL</code> by defining
-<code>GLOG_NO_ABBREVIATED_SEVERITIES</code> before
-including <code>glog/logging.h</code> . Even with this macro, you can
-still use the iostream like logging facilities:
-
-<pre>
-  #define GLOG_NO_ABBREVIATED_SEVERITIES
-  #include &lt;windows.h&gt;
-  #include &lt;glog/logging.h&gt;
-
-  // ...
-
-  LOG(ERROR) &lt;&lt; "This should work";
-  LOG_IF(ERROR, x &gt; y) &lt;&lt; "This should be also OK";
-</pre>
-
-<p>
-However, you cannot
-use <code>INFO</code>, <code>WARNING</code>, <code>ERROR</code>,
-and <code>FATAL</code> anymore for functions defined
-in <code>glog/logging.h</code> .
-
-<pre>
-  #define GLOG_NO_ABBREVIATED_SEVERITIES
-  #include &lt;windows.h&gt;
-  #include &lt;glog/logging.h&gt;
-
-  // ...
-
-  // This won't work.
-  // google::FlushLogFiles(google::ERROR);
-
-  // Use this instead.
-  google::FlushLogFiles(google::GLOG_ERROR);
-</pre>
-
-<p>
-If you don't need <code>ERROR</code> defined
-by <code>windows.h</code>, there are a couple of more workarounds
-which sometimes don't work:
-
-<ul>
-  <li>#define <code>WIN32_LEAN_AND_MEAN</code> or <code>NOGDI</code>
-      <strong>before</strong> you #include <code>windows.h</code> .
-  <li>#undef <code>ERROR</code> <strong>after</strong> you #include
-      <code>windows.h</code> .
-</ul>
-
-<p>See <a href="http://code.google.com/p/google-glog/issues/detail?id=33">
-this issue</a> for more detail.
-
-<hr>
-<address>
-Shinichiro Hamaji<br>
-Gregor Hohpe<br>
-<script type=text/javascript>
-  var lm = new Date(document.lastModified);
-  document.write(lm.toDateString());
-</script>
-</address>
-
-</body>
-</html>

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/9661f956/third_party/glog/src/base/commandlineflags.h
----------------------------------------------------------------------
diff --git a/third_party/glog/src/base/commandlineflags.h b/third_party/glog/src/base/commandlineflags.h
deleted file mode 100644
index c8d5089..0000000
--- a/third_party/glog/src/base/commandlineflags.h
+++ /dev/null
@@ -1,133 +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.
-
-// ---
-// This file is a compatibility layer that defines Google's version of
-// command line flags that are used for configuration.
-//
-// We 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 bool FLAGS_logtostderr;
-// 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.
-#ifndef BASE_COMMANDLINEFLAGS_H__
-#define BASE_COMMANDLINEFLAGS_H__
-
-#include "config.h"
-#include <string>
-#include <string.h>               // for memchr
-#include <stdlib.h>               // for getenv
-
-#ifdef HAVE_LIB_GFLAGS
-
-#include <gflags/gflags.h>
-
-#else
-
-#include "glog/logging.h"
-
-#define DECLARE_VARIABLE(type, shorttype, name, tn)                     \
-  namespace fL##shorttype {                                             \
-    extern GOOGLE_GLOG_DLL_DECL type FLAGS_##name;                      \
-  }                                                                     \
-  using fL##shorttype::FLAGS_##name
-#define DEFINE_VARIABLE(type, shorttype, name, value, meaning, tn)      \
-  namespace fL##shorttype {                                             \
-    GOOGLE_GLOG_DLL_DECL type FLAGS_##name(value);                      \
-    char FLAGS_no##name;                                                \
-  }                                                                     \
-  using fL##shorttype::FLAGS_##name
-
-// bool specialization
-#define DECLARE_bool(name) \
-  DECLARE_VARIABLE(bool, B, name, bool)
-#define DEFINE_bool(name, value, meaning) \
-  DEFINE_VARIABLE(bool, B, name, value, meaning, bool)
-
-// int32 specialization
-#define DECLARE_int32(name) \
-  DECLARE_VARIABLE(GOOGLE_NAMESPACE::int32, I, name, int32)
-#define DEFINE_int32(name, value, meaning) \
-  DEFINE_VARIABLE(GOOGLE_NAMESPACE::int32, I, name, value, meaning, int32)
-
-// Special case for string, because we have to specify the namespace
-// std::string, which doesn't play nicely with our FLAG__namespace hackery.
-#define DECLARE_string(name)                                            \
-  namespace fLS {                                                       \
-    extern GOOGLE_GLOG_DLL_DECL std::string& FLAGS_##name;              \
-  }                                                                     \
-  using fLS::FLAGS_##name
-#define DEFINE_string(name, value, meaning)                             \
-  namespace fLS {                                                       \
-    std::string FLAGS_##name##_buf(value);                              \
-    GOOGLE_GLOG_DLL_DECL std::string& FLAGS_##name = FLAGS_##name##_buf; \
-    char FLAGS_no##name;                                                \
-  }                                                                     \
-  using fLS::FLAGS_##name
-
-#endif  // HAVE_LIB_GFLAGS
-
-// Define GLOG_DEFINE_* using DEFINE_* . By using these macros, we
-// have GLOG_* environ variables even if we have gflags installed.
-//
-// If both an environment variable and a flag are specified, the value
-// specified by a flag wins. E.g., if GLOG_v=0 and --v=1, the
-// verbosity will be 1, not 0.
-
-#define GLOG_DEFINE_bool(name, value, meaning) \
-  DEFINE_bool(name, EnvToBool("GLOG_" #name, value), meaning)
-
-#define GLOG_DEFINE_int32(name, value, meaning) \
-  DEFINE_int32(name, EnvToInt("GLOG_" #name, value), meaning)
-
-#define GLOG_DEFINE_string(name, value, meaning) \
-  DEFINE_string(name, EnvToString("GLOG_" #name, value), meaning)
-
-// These macros (could be functions, but I don't want to bother with a .cc
-// file), make it easier to initialize flags from the environment.
-
-#define EnvToString(envname, dflt)   \
-  (!getenv(envname) ? (dflt) : getenv(envname))
-
-#define EnvToBool(envname, dflt)   \
-  (!getenv(envname) ? (dflt) : memchr("tTyY1\0", getenv(envname)[0], 6) != NULL)
-
-#define EnvToInt(envname, dflt)  \
-  (!getenv(envname) ? (dflt) : strtol(getenv(envname), NULL, 10))
-
-#endif  // BASE_COMMANDLINEFLAGS_H__

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/9661f956/third_party/glog/src/base/googleinit.h
----------------------------------------------------------------------
diff --git a/third_party/glog/src/base/googleinit.h b/third_party/glog/src/base/googleinit.h
deleted file mode 100644
index 5a8b515..0000000
--- a/third_party/glog/src/base/googleinit.h
+++ /dev/null
@@ -1,51 +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.
-
-// ---
-// Author: Jacob Hoffman-Andrews
-
-#ifndef _GOOGLEINIT_H
-#define _GOOGLEINIT_H
-
-class GoogleInitializer {
- public:
-  typedef void (*void_function)(void);
-  GoogleInitializer(const char*, void_function f) {
-    f();
-  }
-};
-
-#define REGISTER_MODULE_INITIALIZER(name, body)                 \
-  namespace {                                                   \
-    static void google_init_module_##name () { body; }          \
-    GoogleInitializer google_initializer_module_##name(#name,   \
-            google_init_module_##name);                         \
-  }
-
-#endif /* _GOOGLEINIT_H */

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/9661f956/third_party/glog/src/base/mutex.h
----------------------------------------------------------------------
diff --git a/third_party/glog/src/base/mutex.h b/third_party/glog/src/base/mutex.h
deleted file mode 100644
index 37527d5..0000000
--- a/third_party/glog/src/base/mutex.h
+++ /dev/null
@@ -1,331 +0,0 @@
-// Copyright (c) 2007, 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: Craig Silverstein.
-//
-// A simple mutex wrapper, supporting locks and read-write locks.
-// You should assume the locks are *not* re-entrant.
-//
-// To use: you should define the following macros in your configure.ac:
-//   ACX_PTHREAD
-//   AC_RWLOCK
-// The latter is defined in ../autoconf.
-//
-// This class is meant to be internal-only and should be wrapped by an
-// internal namespace.  Before you use this module, please give the
-// name of your internal namespace for this module.  Or, if you want
-// to expose it, you'll want to move it to the Google namespace.  We
-// cannot put this class in global namespace because there can be some
-// problems when we have multiple versions of Mutex in each shared object.
-//
-// NOTE: by default, we have #ifdef'ed out the TryLock() method.
-//       This is for two reasons:
-// 1) TryLock() under Windows is a bit annoying (it requires a
-//    #define to be defined very early).
-// 2) TryLock() is broken for NO_THREADS mode, at least in NDEBUG
-//    mode.
-// If you need TryLock(), and either these two caveats are not a
-// problem for you, or you're willing to work around them, then
-// feel free to #define GMUTEX_TRYLOCK, or to remove the #ifdefs
-// in the code below.
-//
-// CYGWIN NOTE: Cygwin support for rwlock seems to be buggy:
-//    http://www.cygwin.com/ml/cygwin/2008-12/msg00017.html
-// Because of that, we might as well use windows locks for
-// cygwin.  They seem to be more reliable than the cygwin pthreads layer.
-//
-// TRICKY IMPLEMENTATION NOTE:
-// This class is designed to be safe to use during
-// dynamic-initialization -- that is, by global constructors that are
-// run before main() starts.  The issue in this case is that
-// dynamic-initialization happens in an unpredictable order, and it
-// could be that someone else's dynamic initializer could call a
-// function that tries to acquire this mutex -- but that all happens
-// before this mutex's constructor has run.  (This can happen even if
-// the mutex and the function that uses the mutex are in the same .cc
-// file.)  Basically, because Mutex does non-trivial work in its
-// constructor, it's not, in the naive implementation, safe to use
-// before dynamic initialization has run on it.
-//
-// The solution used here is to pair the actual mutex primitive with a
-// bool that is set to true when the mutex is dynamically initialized.
-// (Before that it's false.)  Then we modify all mutex routines to
-// look at the bool, and not try to lock/unlock until the bool makes
-// it to true (which happens after the Mutex constructor has run.)
-//
-// This works because before main() starts -- particularly, during
-// dynamic initialization -- there are no threads, so a) it's ok that
-// the mutex operations are a no-op, since we don't need locking then
-// anyway; and b) we can be quite confident our bool won't change
-// state between a call to Lock() and a call to Unlock() (that would
-// require a global constructor in one translation unit to call Lock()
-// and another global constructor in another translation unit to call
-// Unlock() later, which is pretty perverse).
-//
-// That said, it's tricky, and can conceivably fail; it's safest to
-// avoid trying to acquire a mutex in a global constructor, if you
-// can.  One way it can fail is that a really smart compiler might
-// initialize the bool to true at static-initialization time (too
-// early) rather than at dynamic-initialization time.  To discourage
-// that, we set is_safe_ to true in code (not the constructor
-// colon-initializer) and set it to true via a function that always
-// evaluates to true, but that the compiler can't know always
-// evaluates to true.  This should be good enough.
-
-#ifndef GOOGLE_MUTEX_H_
-#define GOOGLE_MUTEX_H_
-
-#include "config.h"           // to figure out pthreads support
-
-#if defined(NO_THREADS)
-  typedef int MutexType;      // to keep a lock-count
-#elif defined(_WIN32) || defined(__CYGWIN32__) || defined(__CYGWIN64__)
-# ifndef WIN32_LEAN_AND_MEAN
-#  define WIN32_LEAN_AND_MEAN  // We only need minimal includes
-# endif
-# ifdef GMUTEX_TRYLOCK
-  // We need Windows NT or later for TryEnterCriticalSection().  If you
-  // don't need that functionality, you can remove these _WIN32_WINNT
-  // lines, and change TryLock() to assert(0) or something.
-#   ifndef _WIN32_WINNT
-#     define _WIN32_WINNT 0x0400
-#   endif
-# endif
-// To avoid macro definition of ERROR.
-# ifndef NOGDI
-#  define NOGDI
-# endif
-// To avoid macro definition of min/max.
-# ifndef NOMINMAX
-#  define NOMINMAX
-# endif
-# include <windows.h>
-  typedef CRITICAL_SECTION MutexType;
-#elif defined(HAVE_PTHREAD) && defined(HAVE_RWLOCK)
-  // Needed for pthread_rwlock_*.  If it causes problems, you could take it
-  // out, but then you'd have to unset HAVE_RWLOCK (at least on linux -- it
-  // *does* cause problems for FreeBSD, or MacOSX, but isn't needed
-  // for locking there.)
-# ifdef __linux__
-#   define _XOPEN_SOURCE 500  // may be needed to get the rwlock calls
-# endif
-# include <pthread.h>
-  typedef pthread_rwlock_t MutexType;
-#elif defined(HAVE_PTHREAD)
-# include <pthread.h>
-  typedef pthread_mutex_t MutexType;
-#else
-# error Need to implement mutex.h for your architecture, or #define NO_THREADS
-#endif
-
-// We need to include these header files after defining _XOPEN_SOURCE
-// as they may define the _XOPEN_SOURCE macro.
-#include <assert.h>
-#include <stdlib.h>      // for abort()
-
-#define MUTEX_NAMESPACE glog_internal_namespace_
-
-namespace MUTEX_NAMESPACE {
-
-class Mutex {
- public:
-  // Create a Mutex that is not held by anybody.  This constructor is
-  // typically used for Mutexes allocated on the heap or the stack.
-  // See below for a recommendation for constructing global Mutex
-  // objects.
-  inline Mutex();
-
-  // Destructor
-  inline ~Mutex();
-
-  inline void Lock();    // Block if needed until free then acquire exclusively
-  inline void Unlock();  // Release a lock acquired via Lock()
-#ifdef GMUTEX_TRYLOCK
-  inline bool TryLock(); // If free, Lock() and return true, else return false
-#endif
-  // Note that on systems that don't support read-write locks, these may
-  // be implemented as synonyms to Lock() and Unlock().  So you can use
-  // these for efficiency, but don't use them anyplace where being able
-  // to do shared reads is necessary to avoid deadlock.
-  inline void ReaderLock();   // Block until free or shared then acquire a share
-  inline void ReaderUnlock(); // Release a read share of this Mutex
-  inline void WriterLock() { Lock(); }     // Acquire an exclusive lock
-  inline void WriterUnlock() { Unlock(); } // Release a lock from WriterLock()
-
-  // TODO(hamaji): Do nothing, implement correctly.
-  inline void AssertHeld() {}
-
- private:
-  MutexType mutex_;
-  // We want to make sure that the compiler sets is_safe_ to true only
-  // when we tell it to, and never makes assumptions is_safe_ is
-  // always true.  volatile is the most reliable way to do that.
-  volatile bool is_safe_;
-
-  inline void SetIsSafe() { is_safe_ = true; }
-
-  // Catch the error of writing Mutex when intending MutexLock.
-  Mutex(Mutex* /*ignored*/) {}
-  // Disallow "evil" constructors
-  Mutex(const Mutex&);
-  void operator=(const Mutex&);
-};
-
-// Now the implementation of Mutex for various systems
-#if defined(NO_THREADS)
-
-// When we don't have threads, we can be either reading or writing,
-// but not both.  We can have lots of readers at once (in no-threads
-// mode, that's most likely to happen in recursive function calls),
-// but only one writer.  We represent this by having mutex_ be -1 when
-// writing and a number > 0 when reading (and 0 when no lock is held).
-//
-// In debug mode, we assert these invariants, while in non-debug mode
-// we do nothing, for efficiency.  That's why everything is in an
-// assert.
-
-Mutex::Mutex() : mutex_(0) { }
-Mutex::~Mutex()            { assert(mutex_ == 0); }
-void Mutex::Lock()         { assert(--mutex_ == -1); }
-void Mutex::Unlock()       { assert(mutex_++ == -1); }
-#ifdef GMUTEX_TRYLOCK
-bool Mutex::TryLock()      { if (mutex_) return false; Lock(); return true; }
-#endif
-void Mutex::ReaderLock()   { assert(++mutex_ > 0); }
-void Mutex::ReaderUnlock() { assert(mutex_-- > 0); }
-
-#elif defined(_WIN32) || defined(__CYGWIN32__) || defined(__CYGWIN64__)
-
-Mutex::Mutex()             { InitializeCriticalSection(&mutex_); SetIsSafe(); }
-Mutex::~Mutex()            { DeleteCriticalSection(&mutex_); }
-void Mutex::Lock()         { if (is_safe_) EnterCriticalSection(&mutex_); }
-void Mutex::Unlock()       { if (is_safe_) LeaveCriticalSection(&mutex_); }
-#ifdef GMUTEX_TRYLOCK
-bool Mutex::TryLock()      { return is_safe_ ?
-                                 TryEnterCriticalSection(&mutex_) != 0 : true; }
-#endif
-void Mutex::ReaderLock()   { Lock(); }      // we don't have read-write locks
-void Mutex::ReaderUnlock() { Unlock(); }
-
-#elif defined(HAVE_PTHREAD) && defined(HAVE_RWLOCK)
-
-#define SAFE_PTHREAD(fncall)  do {   /* run fncall if is_safe_ is true */  \
-  if (is_safe_ && fncall(&mutex_) != 0) abort();                           \
-} while (0)
-
-Mutex::Mutex() {
-  SetIsSafe();
-  if (is_safe_ && pthread_rwlock_init(&mutex_, NULL) != 0) abort();
-}
-Mutex::~Mutex()            { SAFE_PTHREAD(pthread_rwlock_destroy); }
-void Mutex::Lock()         { SAFE_PTHREAD(pthread_rwlock_wrlock); }
-void Mutex::Unlock()       { SAFE_PTHREAD(pthread_rwlock_unlock); }
-#ifdef GMUTEX_TRYLOCK
-bool Mutex::TryLock()      { return is_safe_ ?
-                                    pthread_rwlock_trywrlock(&mutex_) == 0 :
-                                    true; }
-#endif
-void Mutex::ReaderLock()   { SAFE_PTHREAD(pthread_rwlock_rdlock); }
-void Mutex::ReaderUnlock() { SAFE_PTHREAD(pthread_rwlock_unlock); }
-#undef SAFE_PTHREAD
-
-#elif defined(HAVE_PTHREAD)
-
-#define SAFE_PTHREAD(fncall)  do {   /* run fncall if is_safe_ is true */  \
-  if (is_safe_ && fncall(&mutex_) != 0) abort();                           \
-} while (0)
-
-Mutex::Mutex()             {
-  SetIsSafe();
-  if (is_safe_ && pthread_mutex_init(&mutex_, NULL) != 0) abort();
-}
-Mutex::~Mutex()            { SAFE_PTHREAD(pthread_mutex_destroy); }
-void Mutex::Lock()         { SAFE_PTHREAD(pthread_mutex_lock); }
-void Mutex::Unlock()       { SAFE_PTHREAD(pthread_mutex_unlock); }
-#ifdef GMUTEX_TRYLOCK
-bool Mutex::TryLock()      { return is_safe_ ?
-                                 pthread_mutex_trylock(&mutex_) == 0 : true; }
-#endif
-void Mutex::ReaderLock()   { Lock(); }
-void Mutex::ReaderUnlock() { Unlock(); }
-#undef SAFE_PTHREAD
-
-#endif
-
-// --------------------------------------------------------------------------
-// Some helper classes
-
-// MutexLock(mu) acquires mu when constructed and releases it when destroyed.
-class MutexLock {
- public:
-  explicit MutexLock(Mutex *mu) : mu_(mu) { mu_->Lock(); }
-  ~MutexLock() { mu_->Unlock(); }
- private:
-  Mutex * const mu_;
-  // Disallow "evil" constructors
-  MutexLock(const MutexLock&);
-  void operator=(const MutexLock&);
-};
-
-// ReaderMutexLock and WriterMutexLock do the same, for rwlocks
-class ReaderMutexLock {
- public:
-  explicit ReaderMutexLock(Mutex *mu) : mu_(mu) { mu_->ReaderLock(); }
-  ~ReaderMutexLock() { mu_->ReaderUnlock(); }
- private:
-  Mutex * const mu_;
-  // Disallow "evil" constructors
-  ReaderMutexLock(const ReaderMutexLock&);
-  void operator=(const ReaderMutexLock&);
-};
-
-class WriterMutexLock {
- public:
-  explicit WriterMutexLock(Mutex *mu) : mu_(mu) { mu_->WriterLock(); }
-  ~WriterMutexLock() { mu_->WriterUnlock(); }
- private:
-  Mutex * const mu_;
-  // Disallow "evil" constructors
-  WriterMutexLock(const WriterMutexLock&);
-  void operator=(const WriterMutexLock&);
-};
-
-// Catch bug where variable name is omitted, e.g. MutexLock (&mu);
-#define MutexLock(x) COMPILE_ASSERT(0, mutex_lock_decl_missing_var_name)
-#define ReaderMutexLock(x) COMPILE_ASSERT(0, rmutex_lock_decl_missing_var_name)
-#define WriterMutexLock(x) COMPILE_ASSERT(0, wmutex_lock_decl_missing_var_name)
-
-}  // namespace MUTEX_NAMESPACE
-
-using namespace MUTEX_NAMESPACE;
-
-#undef MUTEX_NAMESPACE
-
-#endif  /* #define GOOGLE_MUTEX_H__ */

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/9661f956/third_party/glog/src/config.h.in
----------------------------------------------------------------------
diff --git a/third_party/glog/src/config.h.in b/third_party/glog/src/config.h.in
deleted file mode 100644
index 0c5e8b0..0000000
--- a/third_party/glog/src/config.h.in
+++ /dev/null
@@ -1,171 +0,0 @@
-/* src/config.h.in.  Generated from configure.ac by autoheader.  */
-
-/* define if glog doesn't use RTTI */
-#undef DISABLE_RTTI
-
-/* Namespace for Google classes */
-#undef GOOGLE_NAMESPACE
-
-/* Define if you have the `dladdr' function */
-#undef HAVE_DLADDR
-
-/* Define to 1 if you have the <dlfcn.h> header file. */
-#undef HAVE_DLFCN_H
-
-/* Define to 1 if you have the <execinfo.h> header file. */
-#undef HAVE_EXECINFO_H
-
-/* Define if you have the `fcntl' function */
-#undef HAVE_FCNTL
-
-/* Define to 1 if you have the <glob.h> header file. */
-#undef HAVE_GLOB_H
-
-/* Define to 1 if you have the <inttypes.h> header file. */
-#undef HAVE_INTTYPES_H
-
-/* Define to 1 if you have the `pthread' library (-lpthread). */
-#undef HAVE_LIBPTHREAD
-
-/* Define to 1 if you have the <libunwind.h> header file. */
-#undef HAVE_LIBUNWIND_H
-
-/* define if you have google gflags library */
-#undef HAVE_LIB_GFLAGS
-
-/* define if you have google gmock library */
-#undef HAVE_LIB_GMOCK
-
-/* define if you have google gtest library */
-#undef HAVE_LIB_GTEST
-
-/* define if you have libunwind */
-#undef HAVE_LIB_UNWIND
-
-/* Define to 1 if you have the <memory.h> header file. */
-#undef HAVE_MEMORY_H
-
-/* define if the compiler implements namespaces */
-#undef HAVE_NAMESPACES
-
-/* Define if you have POSIX threads libraries and header files. */
-#undef HAVE_PTHREAD
-
-/* Define to 1 if you have the <pwd.h> header file. */
-#undef HAVE_PWD_H
-
-/* define if the compiler implements pthread_rwlock_* */
-#undef HAVE_RWLOCK
-
-/* Define if you have the `sigaltstack' function */
-#undef HAVE_SIGALTSTACK
-
-/* Define to 1 if you have the <stdint.h> header file. */
-#undef HAVE_STDINT_H
-
-/* Define to 1 if you have the <stdlib.h> header file. */
-#undef HAVE_STDLIB_H
-
-/* Define to 1 if you have the <strings.h> header file. */
-#undef HAVE_STRINGS_H
-
-/* Define to 1 if you have the <string.h> header file. */
-#undef HAVE_STRING_H
-
-/* Define to 1 if you have the <syscall.h> header file. */
-#undef HAVE_SYSCALL_H
-
-/* Define to 1 if you have the <syslog.h> header file. */
-#undef HAVE_SYSLOG_H
-
-/* Define to 1 if you have the <sys/stat.h> header file. */
-#undef HAVE_SYS_STAT_H
-
-/* Define to 1 if you have the <sys/syscall.h> header file. */
-#undef HAVE_SYS_SYSCALL_H
-
-/* Define to 1 if you have the <sys/time.h> header file. */
-#undef HAVE_SYS_TIME_H
-
-/* Define to 1 if you have the <sys/types.h> header file. */
-#undef HAVE_SYS_TYPES_H
-
-/* Define to 1 if you have the <sys/ucontext.h> header file. */
-#undef HAVE_SYS_UCONTEXT_H
-
-/* Define to 1 if you have the <sys/utsname.h> header file. */
-#undef HAVE_SYS_UTSNAME_H
-
-/* Define to 1 if you have the <ucontext.h> header file. */
-#undef HAVE_UCONTEXT_H
-
-/* Define to 1 if you have the <unistd.h> header file. */
-#undef HAVE_UNISTD_H
-
-/* Define to 1 if you have the <unwind.h> header file. */
-#undef HAVE_UNWIND_H
-
-/* define if the compiler supports using expression for operator */
-#undef HAVE_USING_OPERATOR
-
-/* define if your compiler has __attribute__ */
-#undef HAVE___ATTRIBUTE__
-
-/* define if your compiler has __builtin_expect */
-#undef HAVE___BUILTIN_EXPECT
-
-/* define if your compiler has __sync_val_compare_and_swap */
-#undef HAVE___SYNC_VAL_COMPARE_AND_SWAP
-
-/* Define to the sub-directory in which libtool stores uninstalled libraries.
-   */
-#undef LT_OBJDIR
-
-/* Name of package */
-#undef PACKAGE
-
-/* Define to the address where bug reports for this package should be sent. */
-#undef PACKAGE_BUGREPORT
-
-/* Define to the full name of this package. */
-#undef PACKAGE_NAME
-
-/* Define to the full name and version of this package. */
-#undef PACKAGE_STRING
-
-/* Define to the one symbol short name of this package. */
-#undef PACKAGE_TARNAME
-
-/* Define to the home page for this package. */
-#undef PACKAGE_URL
-
-/* Define to the version of this package. */
-#undef PACKAGE_VERSION
-
-/* How to access the PC from a struct ucontext */
-#undef PC_FROM_UCONTEXT
-
-/* Define to necessary symbol if this constant uses a non-standard name on
-   your system. */
-#undef PTHREAD_CREATE_JOINABLE
-
-/* The size of `void *', as computed by sizeof. */
-#undef SIZEOF_VOID_P
-
-/* Define to 1 if you have the ANSI C header files. */
-#undef STDC_HEADERS
-
-/* the namespace where STL code like vector<> is defined */
-#undef STL_NAMESPACE
-
-/* location of source code */
-#undef TEST_SRC_DIR
-
-/* Version number of package */
-#undef VERSION
-
-/* Stops putting the code inside the Google namespace */
-#undef _END_GOOGLE_NAMESPACE_
-
-/* Puts following code inside the Google namespace */
-#undef _START_GOOGLE_NAMESPACE_

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/9661f956/third_party/glog/src/config_cmake.h.in
----------------------------------------------------------------------
diff --git a/third_party/glog/src/config_cmake.h.in b/third_party/glog/src/config_cmake.h.in
deleted file mode 100644
index 3a3ecb0..0000000
--- a/third_party/glog/src/config_cmake.h.in
+++ /dev/null
@@ -1,169 +0,0 @@
-/* define if glog doesn't use RTTI */
-/* #undef DISABLE_RTTI */
-
-/* Namespace for Google classes */
-#define GOOGLE_NAMESPACE google
-
-/* Define if you have the `dladdr' function */
-/* #undef HAVE_DLADDR */
-
-/* Define to 1 if you have the <dlfcn.h> header file. */
-#cmakedefine HAVE_DLFCN_H 1
-
-/* Define to 1 if you have the <execinfo.h> header file. */
-#cmakedefine HAVE_EXECINFO_H 1
-
-/* Define if you have the `fcntl' function */
-#cmakedefine HAVE_FCNTL 1
-
-/* Define to 1 if you have the <glob.h> header file. */
-#cmakedefine HAVE_GLOB_H 1
-
-/* Define to 1 if you have the <inttypes.h> header file. */
-#cmakedefine HAVE_INTTYPES_H 1
-
-/* Define to 1 if you have the `pthread' library (-lpthread). */
-#cmakedefine HAVE_LIBPTHREAD 1
-
-/* Define to 1 if you have the <libunwind.h> header file. */
-#cmakedefine HAVE_LIBUNWIND_H 1
-
-/* define if you have google gflags library */
-/* #undef HAVE_LIB_GFLAGS */
-
-/* define if you have google gmock library */
-/* #undef HAVE_LIB_GMOCK */
-
-/* define if you have google gtest library */
-/* #undef HAVE_LIB_GTEST */
-
-/* define if you have libunwind */
-/* #undef HAVE_LIB_UNWIND */
-
-/* Define to 1 if you have the <memory.h> header file. */
-#cmakedefine HAVE_MEMORY_H 1
-
-/* define if the compiler implements namespaces */
-#define HAVE_NAMESPACES 1
-
-/* Define if you have POSIX threads libraries and header files. */
-#cmakedefine HAVE_PTHREAD 1
-
-/* Define to 1 if you have the <pwd.h> header file. */
-#cmakedefine HAVE_PWD_H 1
-
-/* define if the compiler implements pthread_rwlock_* */
-#cmakedefine HAVE_RWLOCK 1
-
-/* Define if you have the `sigaltstack' function */
-#cmakedefine HAVE_SIGALTSTACK 1
-
-/* Define to 1 if you have the <stdint.h> header file. */
-#cmakedefine HAVE_STDINT_H 1
-
-/* Define to 1 if you have the <stdlib.h> header file. */
-#cmakedefine HAVE_STDLIB_H 1
-
-/* Define to 1 if you have the <strings.h> header file. */
-#cmakedefine HAVE_STRINGS_H 1
-
-/* Define to 1 if you have the <string.h> header file. */
-#cmakedefine HAVE_STRING_H 1
-
-/* Define to 1 if you have the <syscall.h> header file. */
-#cmakedefine HAVE_SYSCALL_H 1
-
-/* Define to 1 if you have the <syslog.h> header file. */
-#cmakedefine HAVE_SYSLOG_H 1
-
-/* Define to 1 if you have the <sys/stat.h> header file. */
-#cmakedefine HAVE_SYS_STAT_H 1
-
-/* Define to 1 if you have the <sys/syscall.h> header file. */
-#cmakedefine HAVE_SYS_SYSCALL_H 1
-
-/* Define to 1 if you have the <sys/time.h> header file. */
-#cmakedefine HAVE_SYS_TIME_H 1
-
-/* Define to 1 if you have the <sys/types.h> header file. */
-#cmakedefine HAVE_SYS_TYPES_H 1
-
-/* Define to 1 if you have the <sys/ucontext.h> header file. */
-#cmakedefine HAVE_SYS_UCONTEXT_H 1
-
-/* Define to 1 if you have the <sys/utsname.h> header file. */
-#cmakedefine HAVE_SYS_UTSNAME_H 1
-
-/* Define to 1 if you have the <ucontext.h> header file. */
-#cmakedefine HAVE_UCONTEXT_H 1
-
-/* Define to 1 if you have the <unistd.h> header file. */
-#cmakedefine HAVE_UNISTD_H 1
-
-/* Define to 1 if you have the <unwind.h> header file. */
-#cmakedefine HAVE_UNWIND_H 1
-
-/* define if the compiler supports using expression for operator */
-#define HAVE_USING_OPERATOR 1
-
-/* define if your compiler has __attribute__ */
-#cmakedefine HAVE___ATTRIBUTE__ 1
-
-/* define if your compiler has __builtin_expect */
-#cmakedefine HAVE___BUILTIN_EXPECT 1
-
-/* define if your compiler has __sync_val_compare_and_swap */
-#cmakedefine HAVE___SYNC_VAL_COMPARE_AND_SWAP 1
-
-/* Define to the sub-directory in which libtool stores uninstalled libraries.
-   */
-#define LT_OBJDIR ".libs/"
-
-/* Name of package */
-#define PACKAGE "glog"
-
-/* Define to the address where bug reports for this package should be sent. */
-#define PACKAGE_BUGREPORT "opensource@google.com"
-
-/* Define to the full name of this package. */
-#define PACKAGE_NAME "glog"
-
-/* Define to the full name and version of this package. */
-#define PACKAGE_STRING "glog 0.3.3"
-
-/* Define to the one symbol short name of this package. */
-#define PACKAGE_TARNAME "glog"
-
-/* Define to the home page for this package. */
-#define PACKAGE_URL ""
-
-/* Define to the version of this package. */
-#define PACKAGE_VERSION "0.3.3"
-
-/* How to access the PC from a struct ucontext */
-#cmakedefine PC_FROM_UCONTEXT ${PC_FROM_UCONTEXT}
-
-/* Define to necessary symbol if this constant uses a non-standard name on
-   your system. */
-/* #undef PTHREAD_CREATE_JOINABLE */
-
-/* The size of `void *', as computed by sizeof. */
-#define SIZEOF_VOID_P ${SIZEOF_VOID_P}
-
-/* Define to 1 if you have the ANSI C header files. */
-/* #undef STDC_HEADERS */
-
-/* the namespace where STL code like vector<> is defined */
-#define STL_NAMESPACE std
-
-/* location of source code */
-#define TEST_SRC_DIR "../glog"
-
-/* Version number of package */
-#define VERSION "0.3.3"
-
-/* Stops putting the code inside the Google namespace */
-#define _END_GOOGLE_NAMESPACE_ }
-
-/* Puts following code inside the Google namespace */
-#define _START_GOOGLE_NAMESPACE_ namespace google {

http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/9661f956/third_party/glog/src/config_for_unittests.h
----------------------------------------------------------------------
diff --git a/third_party/glog/src/config_for_unittests.h b/third_party/glog/src/config_for_unittests.h
deleted file mode 100644
index 13ea8ea..0000000
--- a/third_party/glog/src/config_for_unittests.h
+++ /dev/null
@@ -1,66 +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.
-
-// ---
-// All Rights Reserved.
-//
-// Author: Craig Silverstein
-// Copied from google-perftools and modified by Shinichiro Hamaji
-//
-// This file is needed for windows -- unittests are not part of the
-// glog dll, but still want to include config.h just like the
-// dll does, so they can use internal tools and APIs for testing.
-//
-// The problem is that config.h declares GOOGLE_GLOG_DLL_DECL to be
-// for exporting symbols, but the unittest needs to *import* symbols
-// (since it's not the dll).
-//
-// The solution is to have this file, which is just like config.h but
-// sets GOOGLE_GLOG_DLL_DECL to do a dllimport instead of a dllexport.
-//
-// The reason we need this extra GOOGLE_GLOG_DLL_DECL_FOR_UNITTESTS
-// variable is in case people want to set GOOGLE_GLOG_DLL_DECL explicitly
-// to something other than __declspec(dllexport).  In that case, they
-// may want to use something other than __declspec(dllimport) for the
-// unittest case.  For that, we allow folks to define both
-// GOOGLE_GLOG_DLL_DECL and GOOGLE_GLOG_DLL_DECL_FOR_UNITTESTS explicitly.
-//
-// NOTE: This file is equivalent to config.h on non-windows systems,
-// which never defined GOOGLE_GLOG_DLL_DECL_FOR_UNITTESTS and always
-// define GOOGLE_GLOG_DLL_DECL to the empty string.
-
-#include "config.h"
-
-#undef GOOGLE_GLOG_DLL_DECL
-#ifdef GOOGLE_GLOG_DLL_DECL_FOR_UNITTESTS
-# define GOOGLE_GLOG_DLL_DECL  GOOGLE_GLOG_DLL_DECL_FOR_UNITTESTS
-#else
-// if DLL_DECL_FOR_UNITTESTS isn't defined, use ""
-# define GOOGLE_GLOG_DLL_DECL
-#endif


Mime
View raw message