|
/*
* Copyright (c) 2016, 2022, 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.
*
* 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 SHARE_LOGGING_LOGMESSAGE_HPP
#define SHARE_LOGGING_LOGMESSAGE_HPP
#include "logging/log.hpp"
#include "logging/logMessageBuffer.hpp"
#include "logging/logPrefix.hpp"
#include "logging/logTag.hpp"
// The LogMessage class represents a multi-part/multi-line message
// that is guaranteed to be sent and written to the log outputs
// in a way that prevents interleaving by other log messages.
//
// The interface of LogMessage is very similar to the Log class,
// with printf functions for each level (trace(), debug(), etc).
// The difference is that these functions will append/write to the
// LogMessage, which only buffers the message-parts until the whole
// message is sent to a log (using Log::write). Internal buffers
// are C heap allocated lazily on first write. LogMessages are
// automatically written when they go out of scope.
//
// Example usage:
//
// {
// LogMessage(logging) msg;
// if (msg.is_debug()) {
// msg.debug("debug message");
// msg.trace("additional trace information");
// }
// }
//
// Log outputs on trace level will see both of the messages above,
// and the trace line will immediately follow the debug line.
// They will have identical decorations (apart from level).
// Log outputs on debug level will see the debug message,
// but not the trace message.
//
#define LogMessage(...) LogMessageTemplate<LOG_TAGS(__VA_ARGS__)>
class LogMessageImpl : public LogMessageBuffer {
private:
LogTagSet& _tagset;
bool _has_content;
protected:
LogMessageImpl(LogTagSet& tagset)
: _tagset(tagset),
_has_content(false) {};
public:
~LogMessageImpl() {
if (_has_content) {
flush();
}
}
void flush() {
_tagset.log(*this);
reset();
}
void reset() {
_has_content = false;
LogMessageBuffer::reset();
}
ATTRIBUTE_PRINTF(3, 0)
void vwrite(LogLevelType level, const char* fmt, va_list args) {
if (!_has_content) {
_has_content = true;
set_prefix(_tagset.write_prefix());
}
LogMessageBuffer::vwrite(level, fmt, args);
}
bool is_level(LogLevelType level) const {
return _tagset.is_level(level);
}
#define LOG_LEVEL(level, name) \
bool is_##name() const { \
return _tagset.is_level(LogLevel::level); \
}
LOG_LEVEL_LIST
#undef LOG_LEVEL
};
template <LogTagType T0, LogTagType T1 = LogTag::__NO_TAG, LogTagType T2 = LogTag::__NO_TAG, LogTagType T3 = LogTag::__NO_TAG,
LogTagType T4 = LogTag::__NO_TAG, LogTagType GuardTag = LogTag::__NO_TAG>
class LogMessageTemplate : public LogMessageImpl {
public:
LogMessageTemplate(LogMessageTemplate&&) = default;
LogMessageTemplate()
: LogMessageImpl(LogTagSetMapping<T0, T1, T2, T3, T4>::tagset()) {}
};
#endif // SHARE_LOGGING_LOGMESSAGE_HPP
¤ Dauer der Verarbeitung: 0.21 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.
|
