谷歌日志库GLog 头文件 库文件

// This file is automatically generated from src/glog/logging.h.in // using src/windows/preprocess.sh. // DO NOT EDIT! // 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. // // Author: Ray Sidney // // This file contains #include information about logging-related stuff. // Pretty much everybody needs to #include this file so that they can // log various happenings. // #ifndef _LOGGING_H_ #define _LOGGING_H_ #include <errno.h> #include <string.h> #include <time.h> #include <iosfwd> #include <ostream> #include <sstream> #include <string> #if 0 # include <unistd.h> #endif #include <vector> // Annoying stuff for windows -- makes sure clients can import these functions #ifndef GOOGLE_GLOG_DLL_DECL # if defined(_WIN32) && !defined(__CYGWIN__) # define GOOGLE_GLOG_DLL_DECL __declspec(dllimport) # else # define GOOGLE_GLOG_DLL_DECL # endif #endif #if defined(_MSC_VER) #define GLOG_MSVC_PUSH_DISABLE_WARNING(n) __pragma(warning(push)) \ __pragma(warning(disable:n)) #define GLOG_MSVC_POP_WARNING() __pragma(warning(pop)) #else #define GLOG_MSVC_PUSH_DISABLE_WARNING(n) #define GLOG_MSVC_POP_WARNING() #endif // We care a lot about number of bits things take up. Unfortunately, // systems define their bit-specific ints in a lot of different ways. // We use our own way, and have a typedef to get there. // Note: these commands below may look like "#if 1" or "#if 0", but // that's because they were constructed that way at ./configure time. // Look at logging.h.in to see how they're calculated (based on your config). #if 0 #include <stdint.h> // the normal place uint16_t is defined #endif #if 0 #include <sys/types.h> // the normal place u_int16_t is defined #endif #if 0 #include <inttypes.h> // a third place for uint16_t or u_int16_t #endif #if 0 #include <gflags/gflags.h> #endif namespace google { #if 0 // the C99 format typedef int32_t int32; typedef uint32_t uint32; typedef int64_t int64; typedef uint64_t uint64; #elif 0 // the BSD format typedef int32_t int32; typedef u_int32_t uint32; typedef int64_t int64; typedef u_int64_t uint64; #elif 1 // the windows (vc7) format 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 } // The global value of GOOGLE_STRIP_LOG. All the messages logged to // LOG(XXX) with severity less than GOOGLE_STRIP_LOG will not be displayed. // If it can be determined at compile time that the message will not be // printed, the statement will be compiled out. // // Example: to strip out all INFO and WARNING messages, use the value // of 2 below. To make an exception for WARNING messages from a single // file, add "#define GOOGLE_STRIP_LOG 1" to that file _before_ including // base/logging.h #ifndef GOOGLE_STRIP_LOG #define GOOGLE_STRIP_LOG 0 #endif // GCC can be told that a certain branch is not likely to be taken (for // instance, a CHECK failure), and use that information in static analysis. // Giving it this information can help it optimize for the common case in // the absence of better information (ie. -fprofile-arcs). // #ifndef GOOGLE_PREDICT_BRANCH_NOT_TAKEN #if 0 #define GOOGLE_PREDICT_BRANCH_NOT_TAKEN(x) (__builtin_expect(x, 0)) #define GOOGLE_PREDICT_FALSE(x) (__builtin_expect(x, 0)) #define GOOGLE_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1)) #else #define GOOGLE_PREDICT_BRANCH_NOT_TAKEN(x) x #define GOOGLE_PREDICT_FALSE(x) x #define GOOGLE_PREDICT_TRUE(x) x #endif #endif // Make a bunch of macros for logging. The way to log things is to stream // things to LOG(<a particular severity level>). E.g., // // LOG(INFO) << "Found " << num_cookies << " cookies"; // // You can capture log messages in a string, rather than reporting them // immediately: // // vector<string> errors; // LOG_STRING(ERROR, &errors) << "Couldn't parse cookie #" << cookie_num; // // This pushes back the new error onto 'errors'; if given a NULL pointer, // it reports the error via LOG(ERROR). // // You can also do conditional logging: // // LOG_IF(INFO, num_cookies > 10) << "Got lots of cookies"; // // You can also do occasional logging (log every n'th occurrence of an // event): // // LOG_EVERY_N(INFO, 10) << "Got the " << google::COUNTER << "th cookie"; // // The above will cause log messages to be output on the 1st, 11th, 21st, ... // times it is executed. Note that the special google::COUNTER value is used // to identify which repetition is happening. // // You can also do occasional conditional logging (log every n'th // occurrence of an event, when condition is satisfied): // // LOG_IF_EVERY_N(INFO, (size > 1024), 10) << "Got the " << google::COUNTER // << "th big cookie"; // // You can log messages the first N times your code executes a line. E.g. // // LOG_FIRST_N(INFO, 20) << "Got the " << google::COUNTER << "th cookie"; // // Outputs log messages for the first 20 times it is executed. // // Analogous SYSLOG, SYSLOG_IF, and SYSLOG_EVERY_N macros are available. // These log to syslog as well as to the normal logs. If you use these at // all, you need to be aware that syslog can drastically reduce performance, // especially if it is configured for remote logging! Don't use these // unless you fully understand this and have a concrete need to use them. // Even then, try to minimize your use of them. // // There are also "debug mode" logging macros like the ones above: // // DLOG(INFO) << "Found cookies"; // // DLOG_IF(INFO, num_cookies > 10) << "Got lots of cookies"; // // DLOG_EVERY_N(INFO, 10) << "Got the " << google::COUNTER << "th cookie"; // // All "debug mode" logging is compiled away to nothing for non-debug mode // compiles. // // We also have // // LOG_ASSERT(assertion); // DLOG_ASSERT(assertion); // // which is syntactic sugar for {,D}LOG_IF(FATAL, assert fails) << assertion; // // There are "verbose level" logging macros. They look like // // VLOG(1) << "I'm printed when you run the program with --v=1 or more"; // VLOG(2) << "I'm printed when you run the program with --v=2 or more"; // // These always log at the INFO log level (when they log at all). // The verbose logging can also be turned on module-by-module. For instance, // --vmodule=mapreduce=2,file=1,gfs*=3 --v=0 // will cause: // a. VLOG(2) and lower messages to be printed from mapreduce.{h,cc}