|
/*
* Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
#ifndef __LOG_H_INCLUDED_
#define __LOG_H_INCLUDED_
#include "PlatformLogEvent.h"
#include "tstrings.h"
/* Default logger (Logger::defaultLogger()) writes log messages to
* the default log file.
* Common scenario:
* - main() function configures default logger:
* FileLogAppender appender(_T("my_log_filename.log"));
* Logger::defaultLogger().setAppender(appender);
* Logger::defaultLogger().setLogLevel(LOG_INFO);
* If the default file name and log level are not set,
* _T("jusched.log")/LOG_TRACE are used.
*
* Logger fileName specifies only file name,
* full path for the log file depends on the platform
* (usually value of the TMP env. var)
*/
class Logger;
class StreamLogAppender;
struct LogEvent: public PlatformLogEvent {
tstring logLevel;
tstring fileName;
int lineNum;
tstring funcName;
tstring message;
LogEvent();
friend class Logger;
friend class StreamLogAppender;
private:
static void init(PlatformLogEvent& logEvent);
static void appendFormatted(const PlatformLogEvent& logEvent,
tstring& buffer);
};
class LogAppender {
public:
virtual ~LogAppender() {
}
virtual void append(const LogEvent& v) = 0;
};
class NopLogAppender: public LogAppender {
public:
virtual void append(const LogEvent& v) {};
};
class TeeLogAppender: public LogAppender {
public:
TeeLogAppender(LogAppender* first, LogAppender* second):
first(first), second(second) {
}
virtual ~TeeLogAppender() {
}
virtual void append(const LogEvent& v) {
if (first) {
first->append(v);
}
if (second) {
second->append(v);
}
}
private:
LogAppender* first;
LogAppender* second;
};
/**
* Writes log events to the given std::ostream.
* Supposed to be used with std::cout or std::cerr
*/
class StreamLogAppender: public LogAppender {
public:
explicit StreamLogAppender(std::ostream& consumer) : consumer(&consumer) {
}
virtual void append(const LogEvent& v);
private:
std::ostream* consumer;
};
class Logger {
public:
enum LogLevel {
LOG_TRACE,
LOG_INFO,
LOG_WARNING,
LOG_ERROR
};
static Logger& defaultLogger();
explicit Logger(LogAppender& appender, LogLevel logLevel = LOG_TRACE);
~Logger();
LogAppender& setAppender(LogAppender& v) {
LogAppender& oldAppender = *appender;
appender = &v;
return oldAppender;
}
LogAppender& getAppender() const {
return *appender;
}
void setLogLevel(LogLevel logLevel);
bool isLoggable(LogLevel logLevel) const ;
void log(LogLevel logLevel, LPCTSTR fileName, int lineNum,
LPCTSTR funcName, const tstring& message) const;
void log(LogLevel logLevel, LPCTSTR fileName, int lineNum,
LPCTSTR funcName, const tstrings::any& message) const {
return log(logLevel, fileName, lineNum, funcName, message.tstr());
}
void log(LogLevel logLevel, LPCTSTR fileName, int lineNum,
LPCTSTR funcName, tstring::const_pointer message) const {
return log(logLevel, fileName, lineNum, funcName, tstring(message));
}
// internal class for scope tracing
class ScopeTracer {
public:
ScopeTracer(Logger &logger, LogLevel logLevel, LPCTSTR fileName,
int lineNum, LPCTSTR funcName, const tstring& scopeName);
~ScopeTracer();
private:
const Logger &log;
const LogLevel level;
const tstring file;
const int line;
const tstring func;
const tstring scope;
const bool needLog;
};
private:
static void initializingLogging();
static void initializeLogging();
private:
LogLevel level;
LogAppender* appender;
};
class WithExtraLogAppender {
public:
WithExtraLogAppender(LogAppender& logAppender):
oldLogAppender(Logger::defaultLogger().getAppender()),
newLogAppender(&Logger::defaultLogger().getAppender(),
&logAppender) {
Logger::defaultLogger().setAppender(newLogAppender);
}
virtual ~WithExtraLogAppender() {
Logger::defaultLogger().setAppender(oldLogAppender);
}
private:
LogAppender& oldLogAppender;
TeeLogAppender newLogAppender;
};
// base logging macro
#define LOGGER_LOG(logger, logLevel, message) \
do { \
if (logger.isLoggable(logLevel)) { \
logger.log(logLevel, _T(__FILE__), __LINE__, _T(__FUNCTION__), message); \
} \
} while(false)
// custom logger macros
#define LOGGER_TRACE(logger, message) LOGGER_LOG(logger, Logger::LOG_TRACE, message)
#define LOGGER_INFO(logger, message) LOGGER_LOG(logger, Logger::LOG_INFO, message)
#define LOGGER_WARNING(logger, message) LOGGER_LOG(logger, Logger::LOG_WARNING, message)
#define LOGGER_ERROR(logger, message) LOGGER_LOG(logger, Logger::LOG_ERROR, message)
// scope tracing macros
#define LOGGER_TRACE_SCOPE(logger, scopeName) \
Logger::ScopeTracer tracer__COUNTER__(logger, Logger::LOG_TRACE, _T(__FILE__), __LINE__, _T(__FUNCTION__), scopeName)
#define LOGGER_TRACE_FUNCTION(logger) LOGGER_TRACE_SCOPE(logger, _T(__FUNCTION__))
// default logger macros
#define LOG_TRACE(message) LOGGER_LOG(Logger::defaultLogger(), Logger::LOG_TRACE, message)
#define LOG_INFO(message) LOGGER_LOG(Logger::defaultLogger(), Logger::LOG_INFO, message)
#define LOG_WARNING(message) LOGGER_LOG(Logger::defaultLogger(), Logger::LOG_WARNING, message)
#define LOG_ERROR(message) LOGGER_LOG(Logger::defaultLogger(), Logger::LOG_ERROR, message)
// scope tracing macros
// logs (_T("Entering ") + scopeName) at the beging, (_T("Exiting ") + scopeName) at the end of scope
#define LOG_TRACE_SCOPE(scopeName) LOGGER_TRACE_SCOPE(Logger::defaultLogger(), scopeName)
// logs (_T("Entering ") + functionName) at the beging, (_T("Exiting ") + __FUNCTION__) at the end of scope
#define LOG_TRACE_FUNCTION() LOGGER_TRACE_FUNCTION(Logger::defaultLogger())
#endif // __LOG_H_INCLUDED_
¤ Dauer der Verarbeitung: 0.15 Sekunden
(vorverarbeitet)
¤
|
Haftungshinweis
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
|
