#ifndef __LOGGER_HPP__
#define __LOGGER_HPP__
/************************************************************************/
/* HEALER */
/************************************************************************/
#include <windows.h>
#include <map>
#include <string>
using namespace std;
class MultiThreadLock
{
public:
MultiThreadLock()
{
InitializeCriticalSection(&cs);
}
~MultiThreadLock()
{
DeleteCriticalSection(&cs);
}
void Lock()
{
EnterCriticalSection(&cs);
}
void Unlock()
{
LeaveCriticalSection(&cs);
}
private:
CRITICAL_SECTION cs;
};
class SingleThreadLock
{
public:
SingleThreadLock(){}
~SingleThreadLock(){}
void Lock(){}
void Unlock(){}
};
template<typename T, typename TM>
class Singleton
{
private:
typedef TM ThreadModel;
public:
Singleton()
{
}
~Singleton()
{
}
static T* Instance()
{
static ThreadModel _lock;
if (0 == _store())
{
_lock.Lock();
if (0 == _store())
{
T* pInst = new T();
_store() = pInst;
return _store();
}
_lock.Unlock();
}
return _store();
}
private:
static T*& _store()
{
static T* pInst = 0;
return pInst;
}
};
class _log
{
public:
_log(const char* fileName)
:m_hFile(INVALID_HANDLE_VALUE)
{
m_hFile = CreateFileA(fileName, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, NULL, NULL);
}
~_log()
{
if (INVALID_HANDLE_VALUE != m_hFile)
{
CloseHandle(m_hFile);
}
}
public:
long Write(const char* msg)
{
DWORD dwWrite = 0;
if (INVALID_HANDLE_VALUE != m_hFile)
{
BOOL b = WriteFile(m_hFile, (void*)msg, (DWORD)strlen(msg), &dwWrite, NULL);
}
return dwWrite;
}
private:
HANDLE m_hFile;
};
class logger_manager
{
private:
friend class Singleton;
public:
_log* get_log_ptr(string const& name)
{
map<string, _log*>::iterator iter = map_.find(name);
if (map_.end() == iter)
{
_log* pLog = new _log(name.c_str());
map_[name] = pLog;
return pLog;
}
else
{
return (_log*)(iter->second);
}
}
private:
map<string, _log*> map_;
};
template<class TM>
class logger_helper
{
private:
typedef TM ThreadModel;
static void __do_log(string const& name, const char* msg)
{
static ThreadModel lock;
lock.Lock();
Singleton<logger_manager, TM>::Instance()->get_log_ptr(name)->Write(msg);
lock.Unlock();
}
public:
static void do_log(string const& name, const char* msg)
{
__do_log(name, msg);
}
static void do_log(string const& name, const wchar_t* msg)
{
DWORD dwLen = WideCharToMultiByte(GetACP(), 0, msg, -1, NULL, 0, NULL, NULL);
char* p = new char[dwLen];
WideCharToMultiByte(CP_ACP, 0, msg, dwLen, p, dwLen, NULL, NULL);
__do_log(name, p);
delete[] p;
}
static void do_log(string const& name, long msg)
{
char str[32] = { 0 };
itoa(msg, str, 10);
__do_log(name, str);
}
static void do_log(string const& name, long msg, bool hex)
{
if (hex)
{
char str[32] = { 0 };
itoa(msg, str + 2, 16);
str[0] = '0';
str[1] = 'x';
__do_log(name, str);
}
else
{
do_log(name, msg);
}
}
};
class LOG_DATE
{
};
class LOG_TIME
{
};
class LOG_ENDL
{
};
class LOG_HEX
{
public:
LOG_HEX(long a)
:a_(a)
{
}
operator int() { return a_; }
private:
long a_;
};
class LOG_BIN
{
public:
LOG_BIN(BYTE* b)
:b_(b)
{
}
BYTE* get() { return b_;}
private:
BYTE* b_;
};
class LOG_PROCESS_ID
{
};
class LOG_THREAD_ID
{
};
#define USE_LOGGER_YES 1
#define USE_LOGGER_NO 0
template<int, class>
class logger
{
};
template<class TM>
class logger<USE_LOGGER_YES, TM>
{
private:
typedef TM ThreadModel;
public:
logger(const char* name)
:name_(name)
{
}
logger& operator<<(const char* msg)
{
logger_helper<ThreadModel>::do_log(name_, msg);
return *this;
}
logger& operator<<(const wchar_t* msg)
{
logger_helper::do_log(name_, msg);
return *this;
}
logger& operator<<(long msg)
{
logger_helper<ThreadModel>::do_log(name_, msg);
return *this;
}
logger& operator<<(LOG_DATE)
{
SYSTEMTIME st;
GetSystemTime(&st);
char date[32] = { 0 };
sprintf(date, "%d/%d/%d", st.wMonth, st.wDay, st.wYear);
logger_helper<ThreadModel>::do_log(name_, date);
return *this;
}
logger& operator<<(LOG_TIME)
{
SYSTEMTIME st;
GetSystemTime(&st);
char time[32] = { 0 };
sprintf(time, "%d:%d:%d.%d", st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
logger_helper<ThreadModel>::do_log(name_, time);
return *this;
}
logger& operator<<(LOG_ENDL)
{
logger_helper<ThreadModel>::do_log(name_, "\r\n");
return *this;
}
logger& operator<<(LOG_HEX hex)
{
logger_helper<ThreadModel>::do_log(name_, (int)hex, true);
return *this;
}
logger& operator<<(LOG_THREAD_ID)
{
DWORD dwThreadID = GetCurrentThreadId();
logger_helper<ThreadModel>::do_log(name_, dwThreadID);
return *this;
}
logger& operator<<(LOG_PROCESS_ID)
{
DWORD dwProcID = GetCurrentProcessId();
logger_helper::do_log(name_, dwProcID);
return *this;
}
protected:
void* operator new(size_t s);
private:
string name_;
};
template<class TM>
class logger<USE_LOGGER_NO, TM>
{
public:
logger(const char* name) { }
logger& operator<<(const char*) { return *this; }
logger& operator<<(const wchar_t*) { return *this; }
logger& operator<<(long) { return *this; }
logger& operator<<(LOG_DATE) { return *this; }
logger& operator<<(LOG_TIME) { return *this; }
logger& operator<<(LOG_ENDL) { return *this; }
logger& operator<<(LOG_HEX) { return *this; }
logger& operator<<(LOG_THREAD_ID) { return *this; }
logger& operator<<(LOG_PROCESS_ID) { return *this; }
protected:
void* operator new(size_t);
private:
};
#endif
