Deliver/include/Img_header/LoggerInterface.h

#pragma once
#include <map>
#include <vector>
#include <list>
#include <string>

#define  LOGMGR_CLASS_DECL

namespace DIOS_Kernel
{
	enum LogWriteMode
	{
		WRITEMODE_NONE,
		WRITEMODE_DEBUGVIEW = 1,
		WRITEMODE_LOGFILE = 2,
		WRITEMODE_OUTPUT = 4,
	};

	enum LogInfoType
	{
		LOGINFO_LOGMODULENAME,
		LOGINFO_LOGCONTENT,
		LOGINFO_DATATIME,
		/*LOGINFO_ERRORLINE,
		LOGINFO_ERRORFILENAME,
		LOGINFO_LOGCONTENT,
		LOGINFO_LOGLEVEL,
		LOGINFO_WRITEMODE,

		LOGINFO_MODULES,
		LOGINFO_MSGID,
		LOGINFO_SOURCE,
		LOGINFO_DATE,
		LOGINFO_TIME,
		LOGINFO_HOSTNAME,
		LOGINFO_IP,
		LOGINFO_PROCESSNAME,
		LOGINFO_MSGFILESNAME,
		LOGINFO_LINENAME,
		LOGINFO_PARALIST,
		LOGINFO_FREETEXT,
		LOGINFO_VERSION,
		LOGINFO_COMMENTS,*/
	};

	class ILogControler;
	typedef void(*CallbackWriteFunc)(ILogControler* pLogFileCtrl, const wchar_t* pwszValue);

	class LOGMGR_CLASS_DECL CLogTask
	{
	public:
		virtual ~CLogTask();

		bool SetEnvironment(LogInfoType eKey, const wchar_t* pwszValue);
		bool SetContents(const wchar_t* wszKey, const wchar_t* wszValue);
		CLogTask* Clone();

		bool IsValid();

		typedef struct _stCallbackWriteFunc
		{
			ILogControler* pControler;
			CallbackWriteFunc pFunc;

			_stCallbackWriteFunc()
			{
				memset(this, 0, sizeof(_stCallbackWriteFunc));
			}
		}
		STWriteFunc;
	private:
		CLogTask();
		void Write();

		void AddWriteFunction(const STWriteFunc& stInfo);

		std::map<LogInfoType, std::wstring>* m_pEnvironmentMap;
		std::map<std::wstring, std::wstring>* m_pContentsMap;
		std::vector<STWriteFunc>* m_pvecCallbackWriteFunc;

		friend class ILogMgr;
		friend class ILogControler;
	};

	class LOGMGR_CLASS_DECL ILogMgr
	{
	public:
		CLogTask* CreateLogTask();

		virtual void Fatal(CLogTask* pTask) = 0;
		virtual void Error(CLogTask* pTask) = 0;
		virtual void Warning(CLogTask* pTask) = 0;
		virtual void Info(CLogTask* pTask) = 0;
	protected:
		void WriteTask(CLogTask* pLogTask);
		void AddWriteFunction(CLogTask* pLogTask, const CLogTask::STWriteFunc& stInfo);
	};


	class CDIOSThreadLock;
	class ILogControler;
	class CThreadProcess;
	class LOGMGR_CLASS_DECL CLogMgr : public ILogMgr
	{
	public:
		CLogMgr();
		virtual ~CLogMgr();

		void SetEnvironment(LogInfoType eKey, const wchar_t* pwszValue);
		bool Init(int nWriteMode);
		void WriteEnable(bool bEnable);

		virtual void Fatal(CLogTask* pTask);
		virtual void Error(CLogTask* pTask);
		virtual void Warning(CLogTask* pTask);
		virtual void Info(CLogTask* pTask);

	private:

		static unsigned int LogInfoThread(void* param);
		CLogTask* GetLogInfoFromList();
		int	GetLogListCount();

		bool m_bInit;
		CThreadProcess* m_pThreadProcess;
		std::vector<ILogControler*>* m_pvecControlers;
		std::map<LogInfoType, std::wstring>* m_pEnvironmentMap;
		CDIOSThreadLock*         m_ListLock;
		std::list<CLogTask*>*	 m_pLogList;	//´æ·ÅÐèÒªÏÔʾµÄͼÏñ
		bool m_bWriteEnbale;
	};


	class LOGMGR_CLASS_DECL CLogClient
	{
	public:
		CLogClient(DIOS_Kernel::ILogMgr* plogger);
		virtual ~CLogClient() {};

		bool Init();

		void LogInfo(const wchar_t *wszformat, ...);
		void LogWarning(const wchar_t *wszformat, ...);
		void LogError(const wchar_t *wszformat, ...);
		void LogFatal(const wchar_t *wszformat, ...);
	private:
		DIOS_Kernel::ILogMgr* m_plogger;
		bool m_bInit;
	};

}