PhysicalDevice/Deliver/Include/Logger.temp.cpp

// LogAPI.cpp : 6(Re DLL S&SC3LPr5D5<3v:/J}!#
//

#include "stdafx.h"

#include	<stdarg.h> 
//#include	<windows.h>
//#include	<stdio.h>
#include <iostream>
//#include <vector>
#include <string.h>

#include "Logger.temp.h"
#include "SimpleLog.hpp"

#pragma warning(push)
//#pragma warning(disable:4267)

#define ONE_LOG_MAX_SIZE (524288)

TempLogger * g_Logger = NULL;
SimpleLog* g_SLogger = NULL;
char* log_abuff = nullptr;

void CreateLogger(std::shared_ptr <DIOS::Dev::IOEventCenter>  EventCenter)
{
	g_Logger = new TempLogger(EventCenter);
	if (g_SLogger != NULL)
	{
		if (log_abuff != nullptr)
		{
			delete [] log_abuff;
			log_abuff = nullptr;
		}
		delete g_SLogger;
		g_SLogger = NULL;
	}
}
void CreateLogger(std::string strLogName)
{
	g_SLogger = new SimpleLog(strLogName.c_str());
	log_abuff = new char[ONE_LOG_MAX_SIZE];

	if (g_Logger != NULL)
	{
		delete g_Logger;
		g_Logger = NULL;
	}
}
void ReleaseLogger()
{
	if (g_Logger != NULL)
	{
		delete g_Logger;
		g_Logger = NULL;
	}

	if (g_SLogger != NULL)
	{
		if (log_abuff != nullptr)
		{
			delete[] log_abuff;
			log_abuff = nullptr;
		}

		g_SLogger->Close();
		delete g_SLogger;
		g_SLogger = NULL;
	}

}


void __ReleasePrintA(
					 LOG_LEVEL level,
				     /*char*	file,*/
					 int		line,
					 char*	function,
					 char*	format, 
					 ...
					 )
{
	//char* strFileName;
	DWORD returnedLenth;
	va_list args = NULL;

	if (g_Logger == NULL && g_SLogger == NULL)
	{
		return;
	}

	va_start(args,format);

	//strFileName = strrchr( file, '\\' );

	//if( NULL == strFileName )
	//{
	//	strFileName = file;
	//}
	//else
	//{
	//	strFileName++;
	//}

	if (g_Logger != NULL)
	{
		WaitForSingleObject(g_Logger->dump_Mutex,INFINITE);

		memset(g_Logger->g_log_abuff,0, ONE_LOG_MAX_SIZE);

		sprintf_s(g_Logger->g_log_abuff, ONE_LOG_MAX_SIZE,  "%s (%s) (%d): ",
			g_Logger->GetTime().c_str(), function, line );

		vsprintf_s(&(g_Logger->g_log_abuff[strlen(g_Logger->g_log_abuff)]), ONE_LOG_MAX_SIZE/ sizeof(char) - strlen(g_Logger->g_log_abuff),
			format, args );

		g_Logger->g_log_abuff[strlen(g_Logger->g_log_abuff)] = '\n';

		std::string strLog = g_Logger->g_log_abuff;

		g_Logger->g_EventCenter->OnLog((int)level, strLog);

		ReleaseMutex(g_Logger->dump_Mutex);

	}
	else
	{

		sprintf_s(log_abuff, ONE_LOG_MAX_SIZE, " (%s) (%d): ", function, line);

		vsprintf_s(&(log_abuff[strlen(log_abuff)]), ONE_LOG_MAX_SIZE / sizeof(char) - strlen(log_abuff), format, args);
		//memcpy(&(log_abuff[strlen(log_abuff)]), format, strlen(format));


		switch (level)
		{
		case 	LOG_LEVEL_INIT:
		case	LOG_LEVEL_DEBUG:
		{
			g_SLogger->Debug(log_abuff, args);
			break;
		}
		case	LOG_LEVEL_TRACE:
		case	LOG_LEVEL_INFO:
		{
			g_SLogger->Info(log_abuff, args);
			break;
		}
		case	LOG_LEVEL_WARNING:
		{
			g_SLogger->Warn(log_abuff, args);
			break;
		}
		case	LOG_LEVEL_ERROR:
		{
			g_SLogger->Error(log_abuff, args);
			break;
		}
		case	LOG_LEVEL_FATAL:
		{
			g_SLogger->Fatal(log_abuff, args);
			break;
		}

		default:
			break;
		}

	}
} 

std::string TempLogger::GetTime()
{
	SYSTEMTIME st;
	GetLocalTime(&st);
	char tmp[64] = { 0 };
	sprintf_s(tmp, "[%04d %02d %02d] [%02d:%02d:%02d.%3d]", st.wYear, st.wMonth, st.wDay,st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
	return std::string(tmp);
}

TempLogger::TempLogger(std::shared_ptr <DIOS::Dev::IOEventCenter>  EventCenter)
{
	g_log_abuff = new char[ONE_LOG_MAX_SIZE];
	g_EventCenter = EventCenter;
	dump_Mutex = CreateMutex(0, 0, 0);

}

TempLogger::~TempLogger()
{
	delete[]g_log_abuff;
	g_log_abuff = NULL;
}

#pragma warning(pop)