LogOutputStream.h

Go to the documentation of this file.

// this is for emacs file handling -*- mode: c++; indent-tabs-mode: nil -*-

// -- BEGIN LICENSE BLOCK ----------------------------------------------
// This file is part of FZIs ic_workspace.
//
// This program is free software licensed under the LGPL
// (GNU LESSER GENERAL PUBLIC LICENSE Version 3).
// You can find a copy of this license in LICENSE folder in the top
// directory of the source code.
//
// © Copyright 2014 FZI Forschungszentrum Informatik, Karlsruhe, Germany
//
// -- END LICENSE BLOCK ------------------------------------------------

//----------------------------------------------------------------------
//----------------------------------------------------------------------
#ifndef ICL_CORE_LOGGING_LOG_OUTPUT_STREAM_H_INCLUDED
#define ICL_CORE_LOGGING_LOG_OUTPUT_STREAM_H_INCLUDED

#include <icl_core/BaseTypes.h>
#include <icl_core/os_mem.h>
#include <icl_core/List.h>
#include <icl_core/Noncopyable.h>
#include <icl_core/TimeStamp.h>

#ifdef _SYSTEM_LXRT_
#define ICL_CORE_LOG_OUTPUT_STREAM_USE_FIXED_QUEUE
#else
# include <icl_core/Queue.h>
#endif

#include "icl_core_logging/Constants.h"
#include "icl_core_logging/ImportExport.h"
#include "icl_core_logging/LoggingManager.h"
#include "icl_core_logging/LogLevel.h"
#include "icl_core_logging/Semaphore.h"
#include "icl_core_logging/Thread.h"

namespace icl_core {
namespace logging {

class ICL_CORE_LOGGING_IMPORT_EXPORT LogOutputStream : protected virtual icl_core::Noncopyable
{
public:
  LogOutputStream(const icl_core::String& name, const icl_core::String& config_prefix,
                  icl_core::logging::LogLevel log_level, bool use_worker_thread = true);

  virtual ~LogOutputStream();

  void changeTimeFormat(const char* format) { m_time_format = format; }

  void changeLogFormat(const char *format);

  void push(icl_core::logging::LogLevel log_level, const char *log_stream_description,
            const char *filename, int line, const char *classname, const char *objectname,
            const char *function, const char *text);

  void start();

  void shutdown();

  icl_core::logging::LogLevel getLogLevel() const { return m_log_level; }

  void setLogLevel(icl_core::logging::LogLevel log_level) { m_log_level = log_level; }

  icl_core::String name() const { return m_name; }

  void printConfiguration() const;

#ifdef _IC_BUILDER_DEPRECATED_STYLE_

  ICL_CORE_VC_DEPRECATE_STYLE void ChangeTimeFormat(const char* format) ICL_CORE_GCC_DEPRECATE_STYLE;

  ICL_CORE_VC_DEPRECATE_STYLE void ChangeLogFormat(const char *format)
    ICL_CORE_GCC_DEPRECATE_STYLE;

  ICL_CORE_VC_DEPRECATE_STYLE void Push(icl_core::logging::LogLevel log_level,
                                        const char *log_stream_description, const char *filename,
                                        int line, const char *classname, const char *objectname,
                                        const char *function, const char *text)
    ICL_CORE_GCC_DEPRECATE_STYLE;

  ICL_CORE_VC_DEPRECATE_STYLE void Start() ICL_CORE_GCC_DEPRECATE_STYLE;

  ICL_CORE_VC_DEPRECATE_STYLE void Shutdown() ICL_CORE_GCC_DEPRECATE_STYLE;

  ICL_CORE_VC_DEPRECATE_STYLE_USE(LogOutputStream::getLogLevel)
  icl_core::logging::LogLevel LogLevel() const
    ICL_CORE_GCC_DEPRECATE_STYLE_USE(LogOutputStream::getLogLevel);

  ICL_CORE_VC_DEPRECATE_STYLE void SetLogLevel(icl_core::logging::LogLevel log_level)
    ICL_CORE_GCC_DEPRECATE_STYLE;

  ICL_CORE_VC_DEPRECATE_STYLE icl_core::String Name() const ICL_CORE_GCC_DEPRECATE_STYLE;

  ICL_CORE_VC_DEPRECATE_STYLE void PrintConfiguration() const ICL_CORE_GCC_DEPRECATE_STYLE;

#endif


protected:
  struct LogMessage
  {
    LogMessage(const icl_core::TimeStamp& timestamp = icl_core::TimeStamp(),
               icl_core::logging::LogLevel log_level = eLL_MUTE,
               const char *log_stream = "", const char *filename = "",
               size_t line = 0,
               const char *class_name = "", const char *object_name = "", const char *function_name = "",
               const char *message_text = "");

    icl_core::TimeStamp timestamp;
    icl_core::logging::LogLevel log_level;
    char log_stream[cMAX_IDENTIFIER_LENGTH + 1];
    char filename[cMAX_DESCRIPTION_LENGTH + 1];
    size_t line;
    char class_name[cMAX_IDENTIFIER_LENGTH + 1];
    char object_name[cMAX_DESCRIPTION_LENGTH + 1];
    char function_name[cMAX_IDENTIFIER_LENGTH + 1];
    char message_text[cDEFAULT_LOG_SIZE + 1];
  };

  LogOutputStream(const icl_core::String& name, icl_core::logging::LogLevel log_level,
                  bool use_worker_thread = true);

private:
  friend class LoggingManager;

  struct WorkerThread : public Thread, protected virtual icl_core::Noncopyable
  {
#ifdef ICL_CORE_LOG_OUTPUT_STREAM_USE_FIXED_QUEUE
    WorkerThread(LogOutputStream *output_stream, size_t message_queue_size,
                 icl_core::ThreadPriority priority);
#else
    WorkerThread(LogOutputStream *output_stream, icl_core::ThreadPriority priority);
#endif
    ~WorkerThread();

    virtual void run();

#ifdef ICL_CORE_LOG_OUTPUT_STREAM_USE_FIXED_QUEUE
    void incrementIndex(size_t& index);
    bool isMessageQueueEmpty();
    bool isMessageQueueFull();
#endif

    LogOutputStream *m_output_stream;

#ifdef ICL_CORE_LOG_OUTPUT_STREAM_USE_FIXED_QUEUE
    LogMessage *m_message_queue;
    size_t m_message_queue_size;
    size_t m_message_queue_read_index;
    size_t m_message_queue_write_index;
#else
    typedef icl_core::Queue<LogMessage> MessageQueue;
    MessageQueue m_message_queue;
#endif

    Semaphore *m_mutex;
    Semaphore *m_fill_count;
  };
  friend struct WorkerThread;

  struct LogFormatEntry
  {
    enum EntryType
    {
      eT_TEXT,
      eT_CLASSNAME,
      eT_OBJECTNAME,
      eT_FUNCTION,
      eT_MESSAGE,
      eT_FILENAME,
      eT_LINE,
      eT_LEVEL,
      eT_STREAM,
      eT_TIMESTAMP,
      eT_TIMESTAMP_MS
    };

    LogFormatEntry()
      : type(eT_TEXT), width(0)
    {
      icl_core::os::memset(text, 0, 100);
      icl_core::os::memset(suffix, 0, 100);
    }

    EntryType type;
    size_t width;
    char text[100];
    char suffix[100];
  };

  virtual void onStart() { }
  virtual void pushImpl(const LogMessage& log_message);
  virtual void pushImpl(const std::string& log_line);
  virtual void onShutdown() { }

  void parseLogFormat(const char *format);

  icl_core::String m_name;
  icl_core::logging::LogLevel m_log_level;
  const char *m_time_format;

  bool m_use_worker_thread;
  WorkerThread *m_worker_thread;
  Semaphore m_no_worker_thread_push_mutex;

  Semaphore m_format_mutex;
  icl_core::List<LogFormatEntry> m_log_format;
  icl_core::List<LogFormatEntry> m_new_log_format;

  static const icl_core::String m_default_log_format;
  static const icl_core::ThreadPriority m_default_worker_thread_priority;
};

}
}

#endif