orthanc: Core/Logging.cpp comparison

comparison Core/Logging.cpp @ 3998:b3f09bc9734b

sharing more code between the loggers

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Fri, 05 Jun 2020 18:56:35 +0200
parents	c2b9a7a1c74a
children	02e61695cd83

comparison

equal deleted inserted replaced

-:febe25d03f08
+:b3f09bc9734b
 #include "PrecompiledHeaders.h"
 #include "Logging.h"
+#include "OrthancException.h"
+namespace Orthanc
+{
+namespace Logging
+{
+const char* EnumerationToString(LogLevel level)
+{
+switch (level)
+{
+case LogLevel_ERROR:
+return "ERROR";
+case LogLevel_WARNING:
+return "WARNING";
+case LogLevel_INFO:
+return "INFO";
+case LogLevel_TRACE:
+return "TRACE";
+default:
+throw OrthancException(ErrorCode_ParameterOutOfRange);
+}
+}
+LogLevel StringToLogLevel(const char *level)
+{
+if (strcmp(level, "ERROR") == 0)
+{
+return LogLevel_ERROR;
+}
+else if (strcmp(level, "WARNING") == 0)
+{
+return LogLevel_WARNING;
+}
+else if (strcmp(level, "INFO") == 0)
+{
+return LogLevel_INFO;
+}
+else if (strcmp(level, "TRACE") == 0)
+{
+return LogLevel_TRACE;
+}
+else
+{
+throw OrthancException(ErrorCode_InternalError);
+}
+}
+}
+}
 #if ORTHANC_ENABLE_LOGGING != 1
 namespace Orthanc
 {
 namespace Logging
 globalWarningLogFunc = warningLogfunc;
 globalInfoLogFunc = infoLogFunc;
 globalTraceLogFunc = traceLogFunc;
 }
-InternalLogger::InternalLogger(Level level,
+InternalLogger::InternalLogger(LogLevel level,
 const char* file  /* ignored */,
 int line  /* ignored */) :
 level_(level)
 {
 }
 {
 std::string message = messageStream_.str();
 switch (level_)
 {
-case Level_ERROR:
+case LogLevel_ERROR:
 globalErrorLogFunc(message.c_str());
 break;
-case Level_WARNING:
+case LogLevel_WARNING:
 globalWarningLogFunc(message.c_str());
 break;
-case Level_INFO:
+case LogLevel_INFO:
 if (globalVerbose_)
 {
 globalInfoLogFunc(message.c_str());
 // TODO: stone_console_info(message_.c_str());
 }
 break;
-case Level_TRACE:
+case LogLevel_TRACE:
 if (globalTrace_)
 {
 globalTraceLogFunc(message.c_str());
 }
 break;
 {
 assert(sizeof(_OrthancPluginService) == sizeof(int32_t));
 context_ = reinterpret_cast<OrthancPluginContext*>(context);
 }
-InternalLogger::InternalLogger(Level level,
+InternalLogger::InternalLogger(LogLevel level,
 const char* file  /* ignored */,
 int line  /* ignored */) :
 level_(level)
 {
 }
 std::string message = messageStream_.str();
 if (context_ != NULL)
 {
 switch (level_)
 {
-case Level_ERROR:
+case LogLevel_ERROR:
 context_->InvokeService(context_, _OrthancPluginService_LogError, message.c_str());
 break;
-case Level_WARNING:
+case LogLevel_WARNING:
 context_->InvokeService(context_, _OrthancPluginService_LogWarning, message.c_str());
 break;
-case Level_INFO:
+case LogLevel_INFO:
 context_->InvokeService(context_, _OrthancPluginService_LogInfo, message.c_str());
 break;
-case Level_TRACE:
+case LogLevel_TRACE:
 // Not used by plugins
 break;
 default:
 {
 * Internal logger of Orthanc, that mimics some
 * behavior from Google Log.
 *********************************************************/
 #include "Compatibility.h"
-#include "OrthancException.h"
 #include "Enumerations.h"
 #include "Toolbox.h"
 #if ORTHANC_SANDBOXED == 1
 #  include <stdio.h>
 loggingContext_->error_ = loggingContext_->file_.get();
 loggingContext_->info_ = loggingContext_->file_.get();
 }
-InternalLogger::InternalLogger(const char* level,
+InternalLogger::InternalLogger(LogLevel level,
 const char* file,
 int line) :
 lock_(loggingMutex_),
 stream_(&null_)  // By default, logging to "/dev/null" is simulated
 {
 return;
 }
 try
 {
-LogLevel l = StringToLogLevel(level);
+if ((level == LogLevel_INFO  && !loggingContext_->infoEnabled_) ||
+(level == LogLevel_TRACE && !loggingContext_->traceEnabled_))
-if ((l == LogLevel_Info  && !loggingContext_->infoEnabled_) ||
-(l == LogLevel_Trace && !loggingContext_->traceEnabled_))
 {
 // This logging level is disabled, directly exit and unlock
 // the mutex to speed-up things. The stream is set to "/dev/null"
 lock_.unlock();
 return;
 msg              The user-supplied message"
 In this implementation, "threadid" is not printed.
 **/
+char prefix;
+switch (level)
+{
+case LogLevel_ERROR:
+prefix = 'E';
+break;
+case LogLevel_WARNING:
+prefix = 'W';
+break;
+case LogLevel_INFO:
+prefix = 'I';
+break;
+case LogLevel_TRACE:
+prefix = 'T';
+break;
+default:
+throw OrthancException(ErrorCode_InternalError);
+}
 char date[64];
 sprintf(date, "%c%02d%02d %02d:%02d:%02d.%06d ",
-level[0],
+prefix,
 now.date().month().as_number(),
 now.date().day().as_number(),
 static_cast<int>(duration.hours()),
 static_cast<int>(duration.minutes()),
 static_cast<int>(duration.seconds()),
 {
 fprintf(stderr, "ERROR: Trying to log a message after the finalization of the logging engine\n");
 return;
 }
-switch (l)
+switch (level)
 {
-case LogLevel_Error:
+case LogLevel_ERROR:
 stream_ = loggingContext_->error_;
 break;
-case LogLevel_Warning:
+case LogLevel_WARNING:
 stream_ = loggingContext_->warning_;
 break;
-case LogLevel_Info:
+case LogLevel_INFO:
 if (loggingContext_->infoEnabled_)
 {
 stream_ = loggingContext_->info_;
 }
 break;
-case LogLevel_Trace:
+case LogLevel_TRACE:
 if (loggingContext_->traceEnabled_)
 {
 stream_ = loggingContext_->info_;
 }

Mercurial > hg > orthanc

comparison Core/Logging.cpp @ 3998:b3f09bc9734b