Deliver/include/Log4CPP8.0/Log.Include/DumpLog.Log4CPP.hpp

#pragma once

#include <assert.h>

#include "String.DString.hpp"


//-----------------------------------------------------------------------------
//	DumpLog רÓÃÓÚ Dump, ´¿´â´Ó mLog ¸´ÖƶøÀ´
//-----------------------------------------------------------------------------

namespace DumpLog
{
	extern Log4CPP::Logger * gLogger;

	inline void NewLine ()
	{
		if (! gLogger)  return;
		gLogger->NewLine ();
	}

	inline eSTR::DString ErrorCodeToString (DWORD errorCode)
	{
		if (! gLogger)  return eSTR::DString ();
		return gLogger->ErrorCodeToString (errorCode);
	}

	template <typename... Args>
	inline void Force (const char * fmt, Args && ... args)
	{
		if (! gLogger)  return;
		gLogger->Force (fmt, std::forward <Args> (args)...);
	}

	template <typename... Args>
	inline void Log (const char * fmt, Args && ... args)
	{
		if (! gLogger)  return;
		gLogger->Info (fmt, std::forward <Args> (args)...);
	}

	template <typename... Args>
	inline void Trace (const char * fmt, Args && ... args)
	{
		if (! gLogger)  return;
		gLogger->Trace (fmt, std::forward <Args> (args)...);
	}

	template <typename... Args>
	inline void Debug (const char * fmt, Args && ... args)
	{
		if (! gLogger)  return;
		gLogger->Debug (fmt, std::forward <Args> (args)...);
	}

	template <typename... Args>
	inline void Info (const char * fmt, Args && ... args)
	{
		if (! gLogger)  return;
		gLogger->Info (fmt, std::forward <Args> (args)...);
	}

	template <typename... Args>
	inline void Notice (const char * fmt, Args && ... args)
	{
		if (! gLogger)  return;
		gLogger->Notice (fmt, std::forward <Args> (args)...);
	}

	template <typename... Args>
	inline void Warn (const char * fmt, Args && ... args)
	{
		if (! gLogger)  return;
		gLogger->Warn (fmt, std::forward <Args> (args)...);
	}
	template <typename... Args>
	inline void Warning (const char * fmt, Args && ... args)
	{
		if (! gLogger)  return;
		gLogger->Warn (fmt, std::forward <Args> (args)...);
	}

	template <typename... Args>
	inline void Error (const char * fmt, Args && ... args)
	{
		if (! gLogger)  return;
		gLogger->Error (fmt, std::forward <Args> (args)...);
	}

	template <typename... Args>
	inline void Fatal (const char * fmt, Args && ... args)
	{
		if (! gLogger)  return;
		gLogger->Fatal (fmt, std::forward <Args> (args)...);
	}

	inline void Flush (const eSTR::DString& str)
	{
		if (! gLogger)  return;
		gLogger->LogNoFormat (Log4CPP::enInfo, str, str.GetLength (), false);
	}

	inline void LogNoFormat (int Level, const eSTR::DString & str, bool bWithLayout = false)
	{
		if (! gLogger)  return;
		gLogger->LogNoFormat (Level, str, str.GetLength (), bWithLayout);
	}

	inline void LogNoFormat (int Level, const char * buf, int len, bool bWithLayout = false)
	{
		if (! gLogger)  return;
		gLogger->LogNoFormat (Level, buf, len, bWithLayout);
	}

	inline bool Decide (int Level = Log4CPP::enDetail)
	{
		if (! gLogger)  return false;
		return (gLogger->Decide (Level));
	}

	inline void Close ()
	{
		if (! gLogger)  return;
		gLogger->Close ();
	}
};