FGLog.cpp

/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 Module:       FGLog.cpp
 Author:       Bertrand Coconnier
 Date started: 05/03/24
 Purpose:      Manage the logging of messages
 
  ------------- Copyright (C) 2024 Bertrand Coconnier -------------
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU Lesser General Public License as published by the Free
 Software Foundation; either version 2 of the License, or (at your option) any
 later version.
 
 This program 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 Lesser General Public License for more
 details.
 
 You should have received a copy of the GNU Lesser General Public License along
 with this program; if not, write to the Free Software Foundation, Inc., 59
 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
 Further information about the GNU Lesser General Public License can also be
 found on the world wide web at http://www.gnu.org.
 
FUNCTIONAL DESCRIPTION
--------------------------------------------------------------------------------
This is the place where the logging of messages is managed. The messages can be
sent to the console, to a file, etc.
 
HISTORY
--------------------------------------------------------------------------------
05/03/24   BC    Created
 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
INCLUDES
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
#include <iostream>
#include <string_view>
#include <cstring>
 
#include "FGLog.h"
#include "input_output/FGXMLElement.h"
 
namespace JSBSim {
 
thread_local FGLogger_ptr GlobalLogger = std::make_shared<FGLogConsole>();
 
void SetLogger(FGLogger_ptr logger) { GlobalLogger = logger; }
FGLogger_ptr GetLogger(void) { return GlobalLogger; }
 
const char highint[5]  = {27, '[', '1', 'm', '\0'      };
const char halfint[5]  = {27, '[', '2', 'm', '\0'      };
const char normint[6]  = {27, '[', '2', '2', 'm', '\0' };
const char reset[5]    = {27, '[', '0', 'm', '\0'      };
const char underon[5]  = {27, '[', '4', 'm', '\0'      };
const char underoff[6] = {27, '[', '2', '4', 'm', '\0' };
const char fgblue[6]   = {27, '[', '3', '4', 'm', '\0' };
const char fgcyan[6]   = {27, '[', '3', '6', 'm', '\0' };
const char fgred[6]    = {27, '[', '3', '1', 'm', '\0' };
const char fggreen[6]  = {27, '[', '3', '2', 'm', '\0' };
const char fgdef[6]    = {27, '[', '3', '9', 'm', '\0' };
 
/*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
CLASS IMPLEMENTATION
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
class BufferLogger : public FGLogger
{
public:
  BufferLogger() { logMessageBuffer[0] = '\0'; }
  void FileLocation(const std::string& filename, int line) override {
    this->filename = filename;
    this->line = line;
  }
  void Message(const std::string& message) override;
  void Format(LogFormat format) override;
  const char* c_str(void) const noexcept { return logMessageBuffer; }
  ~BufferLogger() override;
 
private:
  struct MessageToken
  {
    std::string_view messageItem;
    LogFormat format = LogFormat::DEFAULT;
  };
 
  char logMessageBuffer[1024];
  size_t bufferUsed = 0;
  std::vector<MessageToken> tokens;
  std::string filename;
  int line = -1;
};
 
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
void BufferLogger::Message(const std::string& message) {
  if (message.empty()) return;
 
  size_t available = sizeof(logMessageBuffer) - bufferUsed - 1;  // -1 for null terminator
  size_t toCopy = std::min(message.size(), available); // Prevent buffer overflow
 
  if (toCopy > 0) {
    // Copy the message to the buffer
    char* currentPos = logMessageBuffer + bufferUsed;
    memcpy(currentPos, message.c_str(), toCopy);
    bufferUsed += toCopy;
    logMessageBuffer[bufferUsed] = '\0';
    // Store the message in the tokens vector
    auto& new_token = tokens.emplace_back();
    new_token.messageItem = std::string_view(currentPos, toCopy);
  }
}
 
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
void BufferLogger::Format(LogFormat format)
{
  auto& new_token = tokens.emplace_back();
  new_token.format = format;
}
 
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
BufferLogger::~BufferLogger()
{
  if (tokens.empty()) return;
 
  GlobalLogger->SetLevel(log_level);
 
  if (line > 0) GlobalLogger->FileLocation(filename, line);
 
  for (const auto& token : tokens) {
    if (token.messageItem.empty()) {
      GlobalLogger->Format(token.format);
      continue;
    }
    GlobalLogger->Message(std::string(token.messageItem));
  }
  GlobalLogger->Flush();
}
 
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
FGLogging::FGLogging(LogLevel level)
  : logger(GlobalLogger)
{
  logger->SetLevel(level);
}
 
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
void FGLogging::Flush(void)
{
  std::string message = buffer.str();
 
  if (!message.empty()) {
    logger->Message(message);
    buffer.str("");
  }
 
  logger->Flush();
}
 
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
FGLogging& FGLogging::operator<<(LogFormat format)
{
  std::string message = buffer.str();
 
  if (!message.empty()) {
    logger->Message(message);
    buffer.str("");
  }
 
  logger->Format(format);
  return *this;
}
 
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
FGXMLLogging::FGXMLLogging(Element* el, LogLevel level)
  : FGLogging(level)
{
  logger->FileLocation(el->GetFileName(), el->GetLineNumber());
}
 
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
void FGLogConsole::Flush(void) {
  if (log_level >= min_level || log_level == LogLevel::STDOUT) {
    switch (log_level)
    {
    case LogLevel::BULK:
    case LogLevel::DEBUG:
    case LogLevel::INFO:
    case LogLevel::STDOUT:
      std::cout << buffer;
      std::cout.flush(); // Force the message to be immediately displayed in the console
      break;
    default:
      std::cerr << buffer;
      std::cerr.flush(); // Force the message to be immediately displayed in the console
      break;
    }
  }
 
  buffer.clear();
}
 
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
void FGLogConsole::Format(LogFormat format) {
  if (!highlighting) return;
 
  switch (format)
  {
  case LogFormat::RED:
    buffer.append(fgred);
    break;
  case LogFormat::BLUE:
    buffer.append(fgblue);
    break;
  case LogFormat::GREEN:
    buffer.append(fggreen);
    break;
  case LogFormat::CYAN:
    buffer.append(fgcyan);
    break;
  case LogFormat::BOLD:
    buffer.append(highint);
    break;
  case LogFormat::NORMAL:
    buffer.append(normint);
    break;
  case LogFormat::UNDERLINE_ON:
    buffer.append(underon);
    break;
  case LogFormat::UNDERLINE_OFF:
    buffer.append(underoff);
    break;
  case LogFormat::DEFAULT:
    buffer.append(fgdef);
    break;
  case LogFormat::RESET:
  default:
    buffer.append(reset);
    break;
  }
}
 
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
LogException::LogException()
: BaseException(""), FGLogging(std::make_shared<BufferLogger>())
{
  logger->SetLevel(LogLevel::FATAL);
}
 
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
LogException::LogException(LogException& other)
: BaseException(""), FGLogging(other.logger)
{
  other.Flush(); // Make the data buffered in `other` accessible to all copies.
}
 
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
const char* LogException::what() const noexcept
{
  // Although using const_cast is generally discouraged, it is justified here because:
  // 1. The what() method must be const to comply with std::exception interface
  // 2. We need to ensure all buffered messages are flushed before returning the error message
  // 3. Conceptually, getting the complete error message is a "logically const" operation
  //    i.e. from the user's perspective, it doesn't modify the state of the object.
  const_cast<LogException*>(this)->Flush();
  return static_cast<BufferLogger*>(logger.get())->c_str();
}
 
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
XMLLogException::XMLLogException(Element* el)
  : LogException()
{
  logger->FileLocation(el->GetFileName(), el->GetLineNumber());
}
 
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
XMLLogException::XMLLogException(LogException& exception, Element* el)
  : LogException(exception)
{
  logger->FileLocation(el->GetFileName(), el->GetLineNumber());
}
};