nicolas/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

*** This commit represents a complete reformatting of the LLDB source code

Browse Source 
*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751
This commit is contained in:
Kate Stone
2016-09-06 20:57:50 +00:00
parent d5aa733769
commit b9c1b51e45
2780 changed files with 556690 additions and 597060 deletions
Download Patch File Download Diff File Expand all files Collapse all files

700
lldb/source/Core/Log.cpp
View File

@@ -18,8 +18,8 @@
// Other libraries and framework includes
#include "llvm/ADT/SmallString.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Support/Signals.h"
#include "llvm/Support/raw_ostream.h"
// Project includes
#include "lldb/Core/Log.h"
@@ -35,62 +35,31 @@
using namespace lldb;
using namespace lldb_private;
Log::Log () :
m_stream_sp(),
m_options(0),
m_mask_bits(0)
{
}
Log::Log() : m_stream_sp(), m_options(0), m_mask_bits(0) {}
Log::Log (const StreamSP &stream_sp) :
m_stream_sp(stream_sp),
m_options(0),
m_mask_bits(0)
{
}
Log::Log(const StreamSP &stream_sp)
: m_stream_sp(stream_sp), m_options(0), m_mask_bits(0) {}
Log::~Log() = default;
Flags &
Log::GetOptions()
{
return m_options;
}
Flags &Log::GetOptions() { return m_options; }
const Flags &
Log::GetOptions() const
{
return m_options;
}
const Flags &Log::GetOptions() const { return m_options; }
Flags &
Log::GetMask()
{
return m_mask_bits;
}
Flags &Log::GetMask() { return m_mask_bits; }
const Flags &
Log::GetMask() const
{
return m_mask_bits;
}
const Flags &Log::GetMask() const { return m_mask_bits; }
void
Log::PutCString(const char *cstr)
{
Printf("%s", cstr);
}
void Log::PutCString(const char *cstr) { Printf("%s", cstr); }
//----------------------------------------------------------------------
// Simple variable argument logging with flags.
//----------------------------------------------------------------------
void
Log::Printf(const char *format, ...)
{
va_list args;
va_start(args, format);
VAPrintf(format, args);
va_end(args);
void Log::Printf(const char *format, ...) {
va_list args;
va_start(args, format);
VAPrintf(format, args);
va_end(args);
}
//----------------------------------------------------------------------
@@ -98,459 +67,384 @@ Log::Printf(const char *format, ...)
// a callback registered, then we call the logging callback. If we have
// a valid file handle, we also log to the file.
//----------------------------------------------------------------------
void
Log::VAPrintf(const char *format, va_list args)
{
// Make a copy of our stream shared pointer in case someone disables our
// log while we are logging and releases the stream
StreamSP stream_sp(m_stream_sp);
if (stream_sp)
{
static uint32_t g_sequence_id = 0;
StreamString header;
void Log::VAPrintf(const char *format, va_list args) {
// Make a copy of our stream shared pointer in case someone disables our
// log while we are logging and releases the stream
StreamSP stream_sp(m_stream_sp);
if (stream_sp) {
static uint32_t g_sequence_id = 0;
StreamString header;
// Add a sequence ID if requested
if (m_options.Test (LLDB_LOG_OPTION_PREPEND_SEQUENCE))
header.Printf ("%u ", ++g_sequence_id);
// Add a sequence ID if requested
if (m_options.Test(LLDB_LOG_OPTION_PREPEND_SEQUENCE))
header.Printf("%u ", ++g_sequence_id);
// Timestamp if requested
if (m_options.Test (LLDB_LOG_OPTION_PREPEND_TIMESTAMP))
{
TimeValue now = TimeValue::Now();
header.Printf ("%9d.%09.9d ", now.seconds(), now.nanoseconds());
}
// Add the process and thread if requested
if (m_options.Test (LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD))
header.Printf ("[%4.4x/%4.4" PRIx64 "]: ", getpid(), Host::GetCurrentThreadID());
// Add the thread name if requested
if (m_options.Test (LLDB_LOG_OPTION_PREPEND_THREAD_NAME))
{
llvm::SmallString<32> thread_name;
ThisThread::GetName(thread_name);
if (!thread_name.empty())
header.Printf ("%s ", thread_name.c_str());
}
header.PrintfVarArg (format, args);
header.PutCString("\n");
if (m_options.Test(LLDB_LOG_OPTION_BACKTRACE))
{
std::string back_trace;
llvm::raw_string_ostream stream(back_trace);
llvm::sys::PrintStackTrace(stream);
stream.flush();
header.PutCString(back_trace.c_str());
}
if (m_options.Test(LLDB_LOG_OPTION_THREADSAFE))
{
static std::recursive_mutex g_LogThreadedMutex;
std::lock_guard<std::recursive_mutex> guard(g_LogThreadedMutex);
stream_sp->PutCString(header.GetString().c_str());
stream_sp->Flush();
}
else
{
stream_sp->PutCString(header.GetString().c_str());
stream_sp->Flush();
}
// Timestamp if requested
if (m_options.Test(LLDB_LOG_OPTION_PREPEND_TIMESTAMP)) {
TimeValue now = TimeValue::Now();
header.Printf("%9d.%09.9d ", now.seconds(), now.nanoseconds());
}
// Add the process and thread if requested
if (m_options.Test(LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD))
header.Printf("[%4.4x/%4.4" PRIx64 "]: ", getpid(),
Host::GetCurrentThreadID());
// Add the thread name if requested
if (m_options.Test(LLDB_LOG_OPTION_PREPEND_THREAD_NAME)) {
llvm::SmallString<32> thread_name;
ThisThread::GetName(thread_name);
if (!thread_name.empty())
header.Printf("%s ", thread_name.c_str());
}
header.PrintfVarArg(format, args);
header.PutCString("\n");
if (m_options.Test(LLDB_LOG_OPTION_BACKTRACE)) {
std::string back_trace;
llvm::raw_string_ostream stream(back_trace);
llvm::sys::PrintStackTrace(stream);
stream.flush();
header.PutCString(back_trace.c_str());
}
if (m_options.Test(LLDB_LOG_OPTION_THREADSAFE)) {
static std::recursive_mutex g_LogThreadedMutex;
std::lock_guard<std::recursive_mutex> guard(g_LogThreadedMutex);
stream_sp->PutCString(header.GetString().c_str());
stream_sp->Flush();
} else {
stream_sp->PutCString(header.GetString().c_str());
stream_sp->Flush();
}
}
}
//----------------------------------------------------------------------
// Print debug strings if and only if the global debug option is set to
// a non-zero value.
//----------------------------------------------------------------------
void
Log::Debug(const char *format, ...)
{
if (!GetOptions().Test(LLDB_LOG_OPTION_DEBUG))
return;
void Log::Debug(const char *format, ...) {
if (!GetOptions().Test(LLDB_LOG_OPTION_DEBUG))
return;
va_list args;
va_start(args, format);
VAPrintf(format, args);
va_end(args);
va_list args;
va_start(args, format);
VAPrintf(format, args);
va_end(args);
}
//----------------------------------------------------------------------
// Print debug strings if and only if the global debug option is set to
// a non-zero value.
//----------------------------------------------------------------------
void
Log::DebugVerbose(const char *format, ...)
{
if (!GetOptions().AllSet(LLDB_LOG_OPTION_DEBUG | LLDB_LOG_OPTION_VERBOSE))
return;
void Log::DebugVerbose(const char *format, ...) {
if (!GetOptions().AllSet(LLDB_LOG_OPTION_DEBUG | LLDB_LOG_OPTION_VERBOSE))
return;
va_list args;
va_start(args, format);
VAPrintf(format, args);
va_end(args);
va_list args;
va_start(args, format);
VAPrintf(format, args);
va_end(args);
}
//----------------------------------------------------------------------
// Log only if all of the bits are set
//----------------------------------------------------------------------
void
Log::LogIf(uint32_t bits, const char *format, ...)
{
if (!m_options.AllSet(bits))
return;
void Log::LogIf(uint32_t bits, const char *format, ...) {
if (!m_options.AllSet(bits))
return;
va_list args;
va_start(args, format);
VAPrintf(format, args);
va_end(args);
va_list args;
va_start(args, format);
VAPrintf(format, args);
va_end(args);
}
//----------------------------------------------------------------------
// Printing of errors that are not fatal.
//----------------------------------------------------------------------
void
Log::Error(const char *format, ...)
{
va_list args;
va_start(args, format);
VAError(format, args);
va_end(args);
void Log::Error(const char *format, ...) {
va_list args;
va_start(args, format);
VAError(format, args);
va_end(args);
}
void
Log::VAError(const char *format, va_list args)
{
char *arg_msg = nullptr;
::vasprintf(&arg_msg, format, args);
void Log::VAError(const char *format, va_list args) {
char *arg_msg = nullptr;
::vasprintf(&arg_msg, format, args);
if (arg_msg == nullptr)
return;
if (arg_msg == nullptr)
return;
Printf("error: %s", arg_msg);
free(arg_msg);
Printf("error: %s", arg_msg);
free(arg_msg);
}
//----------------------------------------------------------------------
// Printing of errors that ARE fatal. Exit with ERR exit code
// immediately.
//----------------------------------------------------------------------
void
Log::FatalError(int err, const char *format, ...)
{
char *arg_msg = nullptr;
va_list args;
va_start(args, format);
::vasprintf(&arg_msg, format, args);
va_end(args);
void Log::FatalError(int err, const char *format, ...) {
char *arg_msg = nullptr;
va_list args;
va_start(args, format);
::vasprintf(&arg_msg, format, args);
va_end(args);
if (arg_msg != nullptr)
{
Printf("error: %s", arg_msg);
::free(arg_msg);
}
::exit(err);
if (arg_msg != nullptr) {
Printf("error: %s", arg_msg);
::free(arg_msg);
}
::exit(err);
}
//----------------------------------------------------------------------
// Printing of warnings that are not fatal only if verbose mode is
// enabled.
//----------------------------------------------------------------------
void
Log::Verbose(const char *format, ...)
{
if (!m_options.Test(LLDB_LOG_OPTION_VERBOSE))
return;
void Log::Verbose(const char *format, ...) {
if (!m_options.Test(LLDB_LOG_OPTION_VERBOSE))
return;
va_list args;
va_start(args, format);
VAPrintf(format, args);
va_end(args);
va_list args;
va_start(args, format);
VAPrintf(format, args);
va_end(args);
}
//----------------------------------------------------------------------
// Printing of warnings that are not fatal only if verbose mode is
// enabled.
//----------------------------------------------------------------------
void
Log::WarningVerbose(const char *format, ...)
{
if (!m_options.Test(LLDB_LOG_OPTION_VERBOSE))
return;
void Log::WarningVerbose(const char *format, ...) {
if (!m_options.Test(LLDB_LOG_OPTION_VERBOSE))
return;
char *arg_msg = nullptr;
va_list args;
va_start(args, format);
::vasprintf(&arg_msg, format, args);
va_end(args);
char *arg_msg = nullptr;
va_list args;
va_start(args, format);
::vasprintf(&arg_msg, format, args);
va_end(args);
if (arg_msg == nullptr)
return;
if (arg_msg == nullptr)
return;
Printf("warning: %s", arg_msg);
free(arg_msg);
Printf("warning: %s", arg_msg);
free(arg_msg);
}
//----------------------------------------------------------------------
// Printing of warnings that are not fatal.
//----------------------------------------------------------------------
void
Log::Warning(const char *format, ...)
{
char *arg_msg = nullptr;
va_list args;
va_start(args, format);
::vasprintf(&arg_msg, format, args);
va_end(args);
void Log::Warning(const char *format, ...) {
char *arg_msg = nullptr;
va_list args;
va_start(args, format);
::vasprintf(&arg_msg, format, args);
va_end(args);
if (arg_msg == nullptr)
return;
if (arg_msg == nullptr)
return;
Printf("warning: %s", arg_msg);
free(arg_msg);
Printf("warning: %s", arg_msg);
free(arg_msg);
}
typedef std::map <ConstString, Log::Callbacks> CallbackMap;
typedef std::map<ConstString, Log::Callbacks> CallbackMap;
typedef CallbackMap::iterator CallbackMapIter;
typedef std::map <ConstString, LogChannelSP> LogChannelMap;
typedef std::map<ConstString, LogChannelSP> LogChannelMap;
typedef LogChannelMap::iterator LogChannelMapIter;
// Surround our callback map with a singleton function so we don't have any
// global initializers.
static CallbackMap &
GetCallbackMap ()
{
static CallbackMap g_callback_map;
return g_callback_map;
static CallbackMap &GetCallbackMap() {
static CallbackMap g_callback_map;
return g_callback_map;
}
static LogChannelMap &
GetChannelMap ()
{
static LogChannelMap g_channel_map;
return g_channel_map;
static LogChannelMap &GetChannelMap() {
static LogChannelMap g_channel_map;
return g_channel_map;
}
void
Log::RegisterLogChannel (const ConstString &channel, const Log::Callbacks &log_callbacks)
{
GetCallbackMap().insert(std::make_pair(channel, log_callbacks));
void Log::RegisterLogChannel(const ConstString &channel,
const Log::Callbacks &log_callbacks) {
GetCallbackMap().insert(std::make_pair(channel, log_callbacks));
}
bool
Log::UnregisterLogChannel (const ConstString &channel)
{
return GetCallbackMap().erase(channel) != 0;
bool Log::UnregisterLogChannel(const ConstString &channel) {
return GetCallbackMap().erase(channel) != 0;
}
bool
Log::GetLogChannelCallbacks (const ConstString &channel, Log::Callbacks &log_callbacks)
{
CallbackMap &callback_map = GetCallbackMap ();
CallbackMapIter pos = callback_map.find(channel);
if (pos != callback_map.end())
{
log_callbacks = pos->second;
return true;
bool Log::GetLogChannelCallbacks(const ConstString &channel,
Log::Callbacks &log_callbacks) {
CallbackMap &callback_map = GetCallbackMap();
CallbackMapIter pos = callback_map.find(channel);
if (pos != callback_map.end()) {
log_callbacks = pos->second;
return true;
}
::memset(&log_callbacks, 0, sizeof(log_callbacks));
return false;
}
bool Log::EnableLogChannel(lldb::StreamSP &log_stream_sp, uint32_t log_options,
const char *channel, const char **categories,
Stream &error_stream) {
Log::Callbacks log_callbacks;
if (Log::GetLogChannelCallbacks(ConstString(channel), log_callbacks)) {
log_callbacks.enable(log_stream_sp, log_options, categories, &error_stream);
return true;
}
LogChannelSP log_channel_sp(LogChannel::FindPlugin(channel));
if (log_channel_sp) {
if (log_channel_sp->Enable(log_stream_sp, log_options, &error_stream,
categories)) {
return true;
} else {
error_stream.Printf("Invalid log channel '%s'.\n", channel);
return false;
}
::memset (&log_callbacks, 0, sizeof(log_callbacks));
} else {
error_stream.Printf("Invalid log channel '%s'.\n", channel);
return false;
}
}
bool
Log::EnableLogChannel(lldb::StreamSP &log_stream_sp,
uint32_t log_options,
const char *channel,
const char **categories,
Stream &error_stream)
{
Log::Callbacks log_callbacks;
if (Log::GetLogChannelCallbacks (ConstString(channel), log_callbacks))
{
log_callbacks.enable (log_stream_sp, log_options, categories, &error_stream);
return true;
}
LogChannelSP log_channel_sp (LogChannel::FindPlugin (channel));
void Log::EnableAllLogChannels(StreamSP &log_stream_sp, uint32_t log_options,
const char **categories, Stream *feedback_strm) {
CallbackMap &callback_map = GetCallbackMap();
CallbackMapIter pos, end = callback_map.end();
for (pos = callback_map.begin(); pos != end; ++pos)
pos->second.enable(log_stream_sp, log_options, categories, feedback_strm);
LogChannelMap &channel_map = GetChannelMap();
LogChannelMapIter channel_pos, channel_end = channel_map.end();
for (channel_pos = channel_map.begin(); channel_pos != channel_end;
++channel_pos) {
channel_pos->second->Enable(log_stream_sp, log_options, feedback_strm,
categories);
}
}
void Log::AutoCompleteChannelName(const char *channel_name,
StringList &matches) {
LogChannelMap &map = GetChannelMap();
LogChannelMapIter pos, end = map.end();
for (pos = map.begin(); pos != end; ++pos) {
const char *pos_channel_name = pos->first.GetCString();
if (channel_name && channel_name[0]) {
if (NameMatches(channel_name, eNameMatchStartsWith, pos_channel_name)) {
matches.AppendString(pos_channel_name);
}
} else
matches.AppendString(pos_channel_name);
}
}
void Log::DisableAllLogChannels(Stream *feedback_strm) {
CallbackMap &callback_map = GetCallbackMap();
CallbackMapIter pos, end = callback_map.end();
const char *categories[] = {"all", nullptr};
for (pos = callback_map.begin(); pos != end; ++pos)
pos->second.disable(categories, feedback_strm);
LogChannelMap &channel_map = GetChannelMap();
LogChannelMapIter channel_pos, channel_end = channel_map.end();
for (channel_pos = channel_map.begin(); channel_pos != channel_end;
++channel_pos)
channel_pos->second->Disable(categories, feedback_strm);
}
void Log::Initialize() {
Log::Callbacks log_callbacks = {DisableLog, EnableLog, ListLogCategories};
Log::RegisterLogChannel(ConstString("lldb"), log_callbacks);
}
void Log::Terminate() { DisableAllLogChannels(nullptr); }
void Log::ListAllLogChannels(Stream *strm) {
CallbackMap &callback_map = GetCallbackMap();
LogChannelMap &channel_map = GetChannelMap();
if (callback_map.empty() && channel_map.empty()) {
strm->PutCString("No logging channels are currently registered.\n");
return;
}
CallbackMapIter pos, end = callback_map.end();
for (pos = callback_map.begin(); pos != end; ++pos)
pos->second.list_categories(strm);
uint32_t idx = 0;
const char *name;
for (idx = 0;
(name = PluginManager::GetLogChannelCreateNameAtIndex(idx)) != nullptr;
++idx) {
LogChannelSP log_channel_sp(LogChannel::FindPlugin(name));
if (log_channel_sp)
{
if (log_channel_sp->Enable (log_stream_sp, log_options, &error_stream, categories))
{
return true;
}
else
{
error_stream.Printf ("Invalid log channel '%s'.\n", channel);
return false;
}
}
else
{
error_stream.Printf ("Invalid log channel '%s'.\n", channel);
return false;
}
log_channel_sp->ListCategories(strm);
}
}
void
Log::EnableAllLogChannels(StreamSP &log_stream_sp,
uint32_t log_options,
const char **categories,
Stream *feedback_strm)
{
CallbackMap &callback_map = GetCallbackMap ();
CallbackMapIter pos, end = callback_map.end();
bool Log::GetVerbose() const {
// FIXME: This has to be centralized between the stream and the log...
if (m_options.Test(LLDB_LOG_OPTION_VERBOSE))
return true;
for (pos = callback_map.begin(); pos != end; ++pos)
pos->second.enable (log_stream_sp, log_options, categories, feedback_strm);
LogChannelMap &channel_map = GetChannelMap ();
LogChannelMapIter channel_pos, channel_end = channel_map.end();
for (channel_pos = channel_map.begin(); channel_pos != channel_end; ++channel_pos)
{
channel_pos->second->Enable (log_stream_sp, log_options, feedback_strm, categories);
}
}
void
Log::AutoCompleteChannelName (const char *channel_name, StringList &matches)
{
LogChannelMap &map = GetChannelMap ();
LogChannelMapIter pos, end = map.end();
for (pos = map.begin(); pos != end; ++pos)
{
const char *pos_channel_name = pos->first.GetCString();
if (channel_name && channel_name[0])
{
if (NameMatches (channel_name, eNameMatchStartsWith, pos_channel_name))
{
matches.AppendString(pos_channel_name);
}
}
else
matches.AppendString(pos_channel_name);
}
}
void
Log::DisableAllLogChannels (Stream *feedback_strm)
{
CallbackMap &callback_map = GetCallbackMap ();
CallbackMapIter pos, end = callback_map.end();
const char *categories[] = {"all", nullptr};
for (pos = callback_map.begin(); pos != end; ++pos)
pos->second.disable (categories, feedback_strm);
LogChannelMap &channel_map = GetChannelMap ();
LogChannelMapIter channel_pos, channel_end = channel_map.end();
for (channel_pos = channel_map.begin(); channel_pos != channel_end; ++channel_pos)
channel_pos->second->Disable (categories, feedback_strm);
}
void
Log::Initialize()
{
Log::Callbacks log_callbacks = { DisableLog, EnableLog, ListLogCategories };
Log::RegisterLogChannel (ConstString("lldb"), log_callbacks);
}
void
Log::Terminate ()
{
DisableAllLogChannels(nullptr);
}
void
Log::ListAllLogChannels (Stream *strm)
{
CallbackMap &callback_map = GetCallbackMap ();
LogChannelMap &channel_map = GetChannelMap ();
if (callback_map.empty() && channel_map.empty())
{
strm->PutCString ("No logging channels are currently registered.\n");
return;
}
CallbackMapIter pos, end = callback_map.end();
for (pos = callback_map.begin(); pos != end; ++pos)
pos->second.list_categories (strm);
uint32_t idx = 0;
const char *name;
for (idx = 0; (name = PluginManager::GetLogChannelCreateNameAtIndex (idx)) != nullptr; ++idx)
{
LogChannelSP log_channel_sp(LogChannel::FindPlugin (name));
if (log_channel_sp)
log_channel_sp->ListCategories (strm);
}
}
bool
Log::GetVerbose() const
{
// FIXME: This has to be centralized between the stream and the log...
if (m_options.Test(LLDB_LOG_OPTION_VERBOSE))
return true;
// Make a copy of our stream shared pointer in case someone disables our
// log while we are logging and releases the stream
StreamSP stream_sp(m_stream_sp);
if (stream_sp)
return stream_sp->GetVerbose();
return false;
// Make a copy of our stream shared pointer in case someone disables our
// log while we are logging and releases the stream
StreamSP stream_sp(m_stream_sp);
if (stream_sp)
return stream_sp->GetVerbose();
return false;
}
//------------------------------------------------------------------
// Returns true if the debug flag bit is set in this stream.
//------------------------------------------------------------------
bool
Log::GetDebug() const
{
// Make a copy of our stream shared pointer in case someone disables our
// log while we are logging and releases the stream
StreamSP stream_sp(m_stream_sp);
if (stream_sp)
return stream_sp->GetDebug();
return false;
bool Log::GetDebug() const {
// Make a copy of our stream shared pointer in case someone disables our
// log while we are logging and releases the stream
StreamSP stream_sp(m_stream_sp);
if (stream_sp)
return stream_sp->GetDebug();
return false;
}
LogChannelSP
LogChannel::FindPlugin (const char *plugin_name)
{
LogChannelSP log_channel_sp;
LogChannelMap &channel_map = GetChannelMap ();
ConstString log_channel_name (plugin_name);
LogChannelMapIter pos = channel_map.find (log_channel_name);
if (pos == channel_map.end())
{
ConstString const_plugin_name (plugin_name);
LogChannelCreateInstance create_callback = PluginManager::GetLogChannelCreateCallbackForPluginName (const_plugin_name);
if (create_callback)
{
log_channel_sp.reset(create_callback());
if (log_channel_sp)
{
// Cache the one and only loaded instance of each log channel
// plug-in after it has been loaded once.
channel_map[log_channel_name] = log_channel_sp;
}
}
LogChannelSP LogChannel::FindPlugin(const char *plugin_name) {
LogChannelSP log_channel_sp;
LogChannelMap &channel_map = GetChannelMap();
ConstString log_channel_name(plugin_name);
LogChannelMapIter pos = channel_map.find(log_channel_name);
if (pos == channel_map.end()) {
ConstString const_plugin_name(plugin_name);
LogChannelCreateInstance create_callback =
PluginManager::GetLogChannelCreateCallbackForPluginName(
const_plugin_name);
if (create_callback) {
log_channel_sp.reset(create_callback());
if (log_channel_sp) {
// Cache the one and only loaded instance of each log channel
// plug-in after it has been loaded once.
channel_map[log_channel_name] = log_channel_sp;
}
}
else
{
// We have already loaded an instance of this log channel class,
// so just return the cached instance.
log_channel_sp = pos->second;
}
return log_channel_sp;
} else {
// We have already loaded an instance of this log channel class,
// so just return the cached instance.
log_channel_sp = pos->second;
}
return log_channel_sp;
}
LogChannel::LogChannel () :
m_log_ap ()
{
}
LogChannel::LogChannel() : m_log_ap() {}
LogChannel::~LogChannel() = default;