logging.h

Go to the documentation of this file.

#ifndef ION_BASE_LOGGING_H_
#define ION_BASE_LOGGING_H_

#include <functional>
#include <memory>
#include <sstream>
#include <string>

#include "ion/port/logging.h"


namespace ion {
namespace base {

ION_API void SetLogEntryWriter(port::LogEntryWriter* writer);

ION_API port::LogEntryWriter* GetLogEntryWriter();

ION_API port::LogEntryWriter* GetDefaultLogEntryWriter();

ION_API void SetBreakHandler(const std::function<void()>& break_handler);

ION_API void RestoreDefaultBreakHandler();

namespace logging_internal {

class ION_API Logger {
 public:
  Logger(const char* file_name, int line_number, port::LogSeverity severity);
  ~Logger();

  std::ostream& GetStream();

  static const std::string CheckMessage(const char* check_string,
                                        const char* expr_string);

 private:
  port::LogSeverity severity_;
  std::ostringstream stream_;
};

class ION_API NullLogger {
 public:
  NullLogger() {}

  explicit NullLogger(port::LogSeverity severity);
  ~NullLogger() {}

  std::ostream& GetStream();
};

class ION_API SingleLogger {
 public:
  SingleLogger(const char* file_name, int line_number,
               port::LogSeverity severity);
  ~SingleLogger();

  std::ostream& GetStream();

  static void ClearMessages();

 private:
  static bool HasLoggedMessageAt(const char* file_name, int line_number);

  std::unique_ptr<Logger> logger_;
};

class ION_API ThrottledLogger {
 public:
  ThrottledLogger(const char* file_name, int line_number,
                  port::LogSeverity severity, float seconds);
  ~ThrottledLogger();

  std::ostream& GetStream();

 private:
  std::unique_ptr<Logger> logger_;
};

}  // namespace logging_internal
}  // namespace base
}  // namespace ion


#if ION_PRODUCTION

#define ION_LOG(severity) \
  ::ion::base::logging_internal::NullLogger(::ion::port::severity).GetStream()

#define ION_IGNORE_LOG(severity) \
  ::ion::base::logging_internal::NullLogger(::ion::port::severity).GetStream()

#define ION_LOG_ONCE(severity) \
  ::ion::base::logging_internal::NullLogger(::ion::port::severity).GetStream()

#define ION_LOG_EVERY_N_SEC(severity, time) \
  ::ion::base::logging_internal::NullLogger(::ion::port::severity).GetStream()

#else

#define ION_LOG(severity)                                   \
  ::ion::base::logging_internal::Logger(__FILE__, __LINE__, \
                                        ::ion::port::severity).GetStream()

#define ION_IGNORE_LOG(severity) \
  ::ion::base::logging_internal::NullLogger().GetStream()

#define ION_LOG_ONCE(severity)                 \
  ::ion::base::logging_internal::SingleLogger( \
      __FILE__, __LINE__, ::ion::port::severity).GetStream()

#define ION_LOG_EVERY_N_SEC(severity, time)       \
  ::ion::base::logging_internal::ThrottledLogger( \
      __FILE__, __LINE__, ::ion::port::severity, time).GetStream()

#endif



#define LOG(severity) ION_LOG(severity)

#define LOG_ONCE(severity) ION_LOG_ONCE(severity)

#define LOG_EVERY_N_SEC(severity, time) ION_LOG_EVERY_N_SEC(severity, time)
#if ION_DEBUG
#define DLOG(severity) ION_LOG(severity)
#define DLOG_ONCE(severity) ION_LOG_ONCE(severity)
#define DLOG_EVERY_N_SEC(severity, time) ION_LOG_EVERY_N_SEC(severity, time)
#else
#define DLOG(severity) ION_IGNORE_LOG(severity)

#define DLOG_ONCE(severity) ION_IGNORE_LOG(severity)

#define DLOG_EVERY_N_SEC(severity, time) ION_IGNORE_LOG(severity)
#endif

#define ION_LOG_CHECK_MESSAGE(severity, check_type, expr)               \
  LOG(severity) << ::ion::base::logging_internal::Logger::CheckMessage( \
                       check_type, #expr)

#define ION_CHECK(expr) \
  if (expr)             \
    ;                   \
  else                  \
  ION_LOG_CHECK_MESSAGE(FATAL, "CHECK", #expr)

#if ION_DEBUG
#define ION_DCHECK(expr) \
  if (expr)              \
    ;                    \
  else                   \
    ION_LOG_CHECK_MESSAGE(DFATAL, "DCHECK", #expr)
#else
#if defined(ION_PLATFORM_WINDOWS)
#define ION_DCHECK(expr)                                                    \
  (true) ?                                                                  \
  (void)(expr) :                                                            \
  ::ion::base::logging_internal::NullLogger().GetStream()
#else  // defined(ION_PLATFORM_WINDOWS)
#define ION_DCHECK(expr)                                                    \
  if (true || (false && (expr)))                                            \
    ;                                                                       \
  else                                                                      \
    ::ion::base::logging_internal::NullLogger().GetStream()
#endif  // defined(ION_PLATFORM_WINDOWS)
#endif  // ION_DEBUG

#define ION_CHECK_OP(op, val1, val2)                                        \
  ION_CHECK((val1) op (val2)) << "(" << (val1) << " " << #op  /* NOLINT */  \
                              << " " << (val2) << ")\n"
#define ION_DCHECK_OP(op, val1, val2)                                       \
  ION_DCHECK((val1) op (val2)) << "(" << (val1) << " " << #op  /* NOLINT */ \
                               << " " << (val2) << ")\n"

#define CHECK(expr) ION_CHECK(expr)
#define CHECK_EQ(val1, val2) ION_CHECK_OP(==, val1, val2)  // NOLINT
#define CHECK_NE(val1, val2) ION_CHECK_OP(!=, val1, val2)  // NOLINT
#define CHECK_LE(val1, val2) ION_CHECK_OP(<=, val1, val2)  // NOLINT
#define CHECK_LT(val1, val2) ION_CHECK_OP(<, val1, val2)   // NOLINT
#define CHECK_GE(val1, val2) ION_CHECK_OP(>=, val1, val2)  // NOLINT
#define CHECK_GT(val1, val2) ION_CHECK_OP(>, val1, val2)   // NOLINT

#define DCHECK(expr) ION_DCHECK(expr)
#define DCHECK_EQ(val1, val2) ION_DCHECK_OP(==, val1, val2)  // NOLINT
#define DCHECK_NE(val1, val2) ION_DCHECK_OP(!=, val1, val2)  // NOLINT
#define DCHECK_LE(val1, val2) ION_DCHECK_OP(<=, val1, val2)  // NOLINT
#define DCHECK_LT(val1, val2) ION_DCHECK_OP(<, val1, val2)   // NOLINT
#define DCHECK_GE(val1, val2) ION_DCHECK_OP(>=, val1, val2)  // NOLINT
#define DCHECK_GT(val1, val2) ION_DCHECK_OP(>, val1, val2)   // NOLINT

namespace ion {
namespace base {
namespace logging_internal {

template <typename T>
T& CheckNotNullCommon(const char* expr_string, T& t) {  // NOLINT
  if (t == NULL) {
    ION_LOG(FATAL) << Logger::CheckMessage("CHECK_NOTNULL", expr_string);
  }
  return t;
}

template <typename T>
T* CheckNotNull(const char* expr_string, T* t) {  // NOLINT
  return CheckNotNullCommon(expr_string, t);
}

template <typename T>
T& CheckNotNull(const char* expr_string, T& t) {  // NOLINT
  return CheckNotNullCommon(expr_string, t);
}

template <typename T>
const T& CheckNotNull(const char* expr_string, const T& t) {  // NOLINT
  return CheckNotNullCommon(expr_string, t);
}

}  // namespace logging_internal
}  // namespace base
}  // namespace ion

#define CHECK_NOTNULL(val) \
  ::ion::base::logging_internal::CheckNotNull(\
      "'" #val "' Must be non NULL", (val))


#endif  // ION_BASE_LOGGING_H_