anki-3d-engine/include/anki/util/Logger.h

// Copyright (C) 2009-2016, Panagiotis Christopoulos Charitos.
// All rights reserved.
// Code licensed under the BSD License.
// http://www.anki3d.org/LICENSE

#pragma once

#include <anki/Config.h>
#include <anki/util/Singleton.h>
#include <anki/util/Thread.h>

namespace anki
{

// Forward
class File;

/// @addtogroup util_private
/// @{

/// The logger singleton class. The logger cannot print errors or throw
/// exceptions, it has to recover somehow. Its thread safe
/// To add a new signal:
/// @code logger.addMessageHandler((void*)obj, &function) @endcode
class Logger
{
public:
	/// Logger message type
	enum class MessageType : U8
	{
		NORMAL,
		ERROR,
		WARNING,
		FATAL,
		COUNT
	};

	/// Used as parammeter when emitting the signal
	class Info
	{
	public:
		const char* m_file;
		I32 m_line;
		const char* m_func;
		MessageType m_type;
		const char* m_msg;
	};

	/// The message handler callback
	using MessageHandlerCallback = void (*)(void*, const Info& info);

	/// Initialize the logger and add the default message handler
	Logger();

	~Logger();

	/// Add a new message handler
	void addMessageHandler(void* data, MessageHandlerCallback callback);

	/// Add file message handler.
	void addFileMessageHandler(File* file);

	/// Send a message
	void write(const char* file,
		int line,
		const char* func,
		MessageType type,
		const char* msg);

	/// Send a formated message
	void writeFormated(const char* file,
		int line,
		const char* func,
		MessageType type,
		const char* fmt,
		...);

private:
	class Handler
	{
	public:
		void* m_data = nullptr;
		MessageHandlerCallback m_callback = nullptr;

		Handler() = default;

		Handler(const Handler&) = default;

		Handler(void* data, MessageHandlerCallback callback)
			: m_data(data)
			, m_callback(callback)
		{
		}
	};

	Mutex m_mutex; ///< For thread safety
	Array<Handler, 4> m_handlers;
	U32 m_handlersCount = 0;

	static void defaultSystemMessageHandler(void*, const Info& info);
	static void fileMessageHandler(void* file, const Info& info);
};

typedef Singleton<Logger> LoggerSingleton;

#define ANKI_LOGGER_MESSAGE(t, ...)                                            \
	do                                                                         \
	{                                                                          \
		LoggerSingleton::get().writeFormated(                                  \
			ANKI_FILE, __LINE__, ANKI_FUNC, t, __VA_ARGS__);                   \
	} while(false);
/// @}

/// @addtogroup util_logging
/// @{

/// Log information message.
#define ANKI_LOGI(...)                                                         \
	ANKI_LOGGER_MESSAGE(Logger::MessageType::NORMAL, __VA_ARGS__)

/// Log warning message.
#define ANKI_LOGW(...)                                                         \
	ANKI_LOGGER_MESSAGE(Logger::MessageType::WARNING, __VA_ARGS__)

/// Log error message.
#define ANKI_LOGE(...)                                                         \
	ANKI_LOGGER_MESSAGE(Logger::MessageType::ERROR, __VA_ARGS__)

/// Log fatal message. It will will abort.
#define ANKI_LOGF(...)                                                         \
	ANKI_LOGGER_MESSAGE(Logger::MessageType::FATAL, __VA_ARGS__)
/// @}

} // end namespace anki