myvtm/Framework/spbase/SpHelper.cpp

#include "stdafx.h"
#include "precompile.h"
#include "SpHelper.h"
#include "SimpleString.h"
#include "iobuffer.h"
#include "memutil.h"
#include <winpr/wlog.h>
#define TAG SPBASE_TAG("SpHelper")

//
// SpBuffer
//

template<class T>
static inline void WriteT(iobuffer_t *iobuf, T &t)
{
	iobuffer_write(iobuf, IOBUF_T_BUF, &t, sizeof(t));
}

template<class T>
static inline void WriteT(iobuffer_t *iobuf, const T &t)
{
	iobuffer_write(iobuf, IOBUF_T_BUF, &t, sizeof(t));
}


template<class T>
static inline void WriteArrayT(iobuffer_t *iobuf, CAutoArray<T> &t)
{
	int nArrayNum = t.GetCount();
	iobuffer_write(iobuf, IOBUF_T_I4, &nArrayNum, 0);

	for(int i=0; i<nArrayNum; i++)
	{
		WriteT(iobuf, t[i]);
	}
}

template<class T>
static inline void WriteArrayT(iobuffer_t *iobuf, const CAutoArray<T> &t)
{
	int nArrayNum = t.GetCount();
	iobuffer_write(iobuf, IOBUF_T_I4, &nArrayNum, 0);

	for(int i=0; i<nArrayNum; i++)
	{
		WriteT(iobuf, t[i]);
	}
}

template<>
#ifdef _WIN32
static
#endif //_WIN32
inline void WriteT(iobuffer_t* iobuf, CSimpleStringA& t)
{
    CSimpleStringW wt = CSimpleStringA2W(t); // string is unicode so we can compatible with silverlight
    iobuffer_write(iobuf, IOBUF_T_WTSTR, wt.GetData(), -1);
}

template<>
#ifdef _WIN32
static
#endif //_WIN32
inline void WriteT(iobuffer_t* iobuf, const CSimpleStringA& t)
{
    CSimpleStringW wt = CSimpleStringA2W(t); // string is unicode so we can compatible with silverlight
    iobuffer_write(iobuf, IOBUF_T_WTSTR, wt.GetData(), -1);
}

template<>
#ifdef _WIN32
static
#endif //_WIN32
inline void WriteT(iobuffer_t *iobuf, CSimpleStringW &t)
{
	iobuffer_write(iobuf, IOBUF_T_WTSTR, t.GetData(), -1);
}

#ifndef _WIN32

template<>
inline void WriteT(iobuffer_t* iobuf, CSimpleString16Bit& t)
{
    iobuffer_write(iobuf, IOBUF_T_WSTR, t.GetData(), -1);
}

#endif //NOT _WIN32


template<>
#ifdef _WIN32
static
#endif //_WIN32
inline void WriteT(iobuffer_t *iobuf, const CSimpleStringW &t)
{
	iobuffer_write(iobuf, IOBUF_T_WTSTR, t.GetData(), -1);
}

#ifndef _WIN32

template<>
inline void WriteT(iobuffer_t* iobuf, const CSimpleString16Bit& t)
{
    iobuffer_write(iobuf, IOBUF_T_WSTR, t.GetData(), -1);
}

#endif //NOT _WIN32

template<>
#ifdef _WIN32
static
#endif //_WIN32
inline void WriteT(iobuffer_t *iobuf, CBlob &t)
{
	iobuffer_write(iobuf, IOBUF_T_I4, &t.m_iLength, 0);
	iobuffer_write(iobuf, IOBUF_T_BUF, t.m_pData, t.m_iLength);
}

template<>
#ifdef _WIN32
static
#endif //_WIN32
inline void WriteT(iobuffer_t *iobuf, const CBlob &t)
{
	iobuffer_write(iobuf, IOBUF_T_I4, &t.m_iLength, 0);
	iobuffer_write(iobuf, IOBUF_T_BUF, t.m_pData, t.m_iLength);
}

template<class T>
static inline void ReadT(iobuffer_t *iobuf, T &t)
{
	int size = sizeof(t);
	iobuffer_read(iobuf, IOBUF_T_BUF, &t, &size);
}

template<class T>
static inline void ReadArrayT(iobuffer_t *iobuf, CAutoArray<T> &t)
{
	int nArrayNum(0);
	iobuffer_read(iobuf, IOBUF_T_I4, &nArrayNum, NULL);
	if (nArrayNum >0)
	{
		t.Init(nArrayNum);

		for(int i=0; i<nArrayNum; i++)
		{
			ReadT(iobuf, t[i]);
		}
	}
}

template<>
#ifdef _WIN32
static
#endif //_WIN32
inline void ReadT(iobuffer_t* iobuf, CSimpleStringA& t)
{
	SPCHAR* wt = NULL;
    iobuffer_format_read(iobuf, IOBUF_WSTR_FLAG, &wt);
    CSimpleStringW wStr = wt;
    FREE(wt);
    t = CSimpleStringW2A(wStr);
}


template<>
#ifdef _WIN32
static
#endif //_WIN32
inline void ReadT(iobuffer_t * iobuf, CSimpleStringW& t)
{
	SPCHAR* wt = NULL;
	iobuffer_format_read(iobuf, IOBUF_WSTR_FLAG, &wt);
	t = wt;
	FREE(wt);
}

#ifndef _WIN32

template<>
inline void ReadT(iobuffer_t* iobuf, CSimpleString16Bit& t)
{
	WCHAR* wt = NULL;
    iobuffer_format_read(iobuf, "w", &wt);
    t = wt;
    FREE(wt);
}

#endif //NOT _WIN32

template<>
#ifdef _WIN32
static
#endif //_WIN32
inline void ReadT(iobuffer_t *iobuf, CBlob &t)
{
	t.Clear();
	iobuffer_read(iobuf, IOBUF_T_I4, &t.m_iLength, NULL);
	if (t.m_iLength) {
		void *p = new char[t.m_iLength];
		iobuffer_read(iobuf, IOBUF_T_BUF, p, &t.m_iLength);
		t.m_pData = (char*)p;
		t.m_bManaged = true;
	}
}

template<class T>
static inline void DoT(iobuffer_t *iobuf, int mode, T &t)
{
	if (mode == SpBuffer::OP_READ) {
		ReadT(iobuf, t);
	} else {
		WriteT(iobuf, t);
	}
}

template<class T>
static inline void DoArrayT(iobuffer_t *iobuf, int mode, T &t)
{
	if (mode == SpBuffer::OP_READ) {
		ReadArrayT(iobuf, t);
	} else {
		WriteArrayT(iobuf, t);
	}
}

SpBuffer::SpBuffer() : m_pInternalBuf(NULL) 
{

}

SpBuffer::~SpBuffer() 
{ 
	Close();
}

bool SpBuffer::OpenRead(const char *buf, int size)
{
	_ASSERT(!m_pInternalBuf);
	m_pInternalBuf = iobuffer_create(0, size);
	memcpy(iobuffer_data(m_pInternalBuf, 0), buf, size);
	iobuffer_push_count(m_pInternalBuf, size);
	m_iMode = OP_READ;
	return true;
}

bool SpBuffer::OpenRead(iobuffer_t **iobuf)
{
	_ASSERT(!m_pInternalBuf);
	_ASSERT(iobuf && *iobuf);
	m_pInternalBuf = *iobuf;
	*iobuf = NULL;
	m_iMode = OP_READ;
	return true;
}

bool SpBuffer::OpenWrite(int cap)
{
	_ASSERT(!m_pInternalBuf);
	m_pInternalBuf = iobuffer_create(0, cap);
	m_iMode = OP_WRITE;
	return true;
}

void SpBuffer::Close()
{
	if (m_pInternalBuf) {
		iobuffer_destroy(m_pInternalBuf);
		m_pInternalBuf = NULL;
	}
}

void SpBuffer::SetCapacity(int cap)
{
	iobuffer_set_capacity(m_pInternalBuf, cap);
}

void SpBuffer::SetLength(int len)
{
	iobuffer_set_length(m_pInternalBuf, len);
}

int SpBuffer::GetCapacity()
{
	return iobuffer_get_capacity(m_pInternalBuf);
}

int SpBuffer::GetLength()
{
	return iobuffer_get_length(m_pInternalBuf);
}

SpBuffer & SpBuffer::operator &(bool& v)
{
	DoT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(ULONGLONG  &v)
{
	DoT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(LONGLONG &v)
{
	DoT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(INT &v)
{
	DoT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(SHORT &v)
{
	DoT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(CHAR &v)
{
	DoT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(DWORD &v)
{
	DoT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(WORD &v)
{
	DoT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(BYTE &v)
{
	DoT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(FLOAT &v)
{
	DoT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(DOUBLE &v)
{
	DoT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(CBlob& v)
{
	DoT(m_pInternalBuf, m_iMode, v);
	return *this;
}

// compatible with Silverlight, because silverlight only support UNICODE string and 
// does not support GB2312 encoding

SpBuffer & SpBuffer::operator &(CSimpleStringA &v)
{
	DoT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(CSimpleStringW &v)
{
	DoT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(CAutoArray<bool> &v)
{
	DoArrayT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(CAutoArray<ULONGLONG> &v)
{
	DoArrayT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(CAutoArray<LONGLONG> &v)
{
	DoArrayT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(CAutoArray<INT> &v)
{
	DoArrayT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(CAutoArray<SHORT> &v)
{
	DoArrayT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(CAutoArray<CHAR> &v)
{
	DoArrayT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(CAutoArray<DWORD> &v)
{
	DoArrayT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(CAutoArray<WORD> &v)
{
	DoArrayT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(CAutoArray<BYTE> &v)
{
	DoArrayT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(CAutoArray<FLOAT> &v)
{
	DoArrayT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(CAutoArray<DOUBLE> &v)
{
	DoArrayT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(CAutoArray<CSimpleStringA> &v)
{
	DoArrayT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(CAutoArray<CSimpleStringW> &v)
{
	DoArrayT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(CAutoArray<CBlob> &v)
{
	DoArrayT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(const bool&v)
{
	WriteT(m_pInternalBuf, v);
	return *this;
}
SpBuffer & SpBuffer::operator &(const ULONGLONG&v)
{
	WriteT(m_pInternalBuf, v);
	return *this;
}
SpBuffer & SpBuffer::operator &(const LONGLONG&v)
{
	WriteT(m_pInternalBuf, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(const INT&v)
{
	WriteT(m_pInternalBuf, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(const SHORT&v)
{
	WriteT(m_pInternalBuf, v);
	return *this;
}
SpBuffer & SpBuffer::operator &(const CHAR&v)
{
	WriteT(m_pInternalBuf, v);
	return *this;
}
SpBuffer & SpBuffer::operator &(const DWORD&v)
{
	WriteT(m_pInternalBuf, v);
	return *this;
}
SpBuffer & SpBuffer::operator &(const WORD&v)
{
	WriteT(m_pInternalBuf, v);
	return *this;
}
SpBuffer & SpBuffer::operator &(const BYTE&v)
{
	WriteT(m_pInternalBuf, v);
	return *this;
}
SpBuffer & SpBuffer::operator &(const FLOAT&v)
{
	WriteT(m_pInternalBuf, v);
	return *this;
}
SpBuffer & SpBuffer::operator &(const DOUBLE&v)
{
	WriteT(m_pInternalBuf, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(const CSimpleStringA &v)
{
	WriteT(m_pInternalBuf, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(const CSimpleStringW &v)
{
	WriteT(m_pInternalBuf, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(const CBlob&v)
{
	WriteT(m_pInternalBuf, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(const CAutoArray<bool> &v)
{
	WriteArrayT(m_pInternalBuf, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(const CAutoArray<ULONGLONG> &v)
{
	WriteArrayT(m_pInternalBuf, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(const CAutoArray<LONGLONG> &v)
{
	WriteArrayT(m_pInternalBuf, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(const CAutoArray<INT> &v)
{
	WriteArrayT(m_pInternalBuf, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(const CAutoArray<SHORT> &v)
{
	WriteArrayT(m_pInternalBuf, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(const CAutoArray<CHAR> &v)
{
	WriteArrayT(m_pInternalBuf, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(const CAutoArray<DWORD> &v)
{
	WriteArrayT(m_pInternalBuf, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(const CAutoArray<WORD> &v)
{
	WriteArrayT(m_pInternalBuf, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(const CAutoArray<BYTE> &v)
{
	WriteArrayT(m_pInternalBuf, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(const CAutoArray<FLOAT> &v)
{
	WriteArrayT(m_pInternalBuf, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(const CAutoArray<DOUBLE> &v)
{
	WriteArrayT(m_pInternalBuf, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(const CAutoArray<CSimpleStringA> &v)
{
	WriteArrayT(m_pInternalBuf, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(const CAutoArray<CSimpleStringW> &v)
{
	WriteArrayT(m_pInternalBuf, v);
	return *this;
}

SpBuffer & SpBuffer::operator &(const CAutoArray<CBlob> &v)
{
	WriteArrayT(m_pInternalBuf, v);
	return *this;
}


#ifdef _WIN32

SpBuffer& SpBuffer::operator &(UINT& v)
{
	DoT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer& SpBuffer::operator &(const UINT& v)
{
	WriteT(m_pInternalBuf, v);
	return *this;
}

SpBuffer& SpBuffer::operator &(CAutoArray<UINT>& v)
{
	DoArrayT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer& SpBuffer::operator &(const CAutoArray<UINT>& v)
{
	WriteArrayT(m_pInternalBuf, v);
	return *this;
}

SpBuffer& SpBuffer::operator &(LONG& v)
{
	DoT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer& SpBuffer::operator &(CAutoArray<LONG>& v)
{
	DoArrayT(m_pInternalBuf, m_iMode, v);
	return *this;
}

SpBuffer& SpBuffer::operator &(const LONG& v)
{
	WriteT(m_pInternalBuf, v);
	return *this;
}

SpBuffer& SpBuffer::operator &(const CAutoArray<LONG>& v)
{
	WriteArrayT(m_pInternalBuf, v);
	return *this;
}

//SpBuffer& SpBuffer::operator &(ULONG& v)
//{
//	DoT(m_pInternalBuf, m_iMode, v);
//	return *this;
//}
//SpBuffer& SpBuffer::operator &(CAutoArray<ULONG>& v)
//{
//	DoArrayT(m_pInternalBuf, m_iMode, v);
//	return *this;
//}
//SpBuffer& SpBuffer::operator &(const ULONG& v)
//{
//	WriteT(m_pInternalBuf, v);
//	return *this;
//}
//SpBuffer& SpBuffer::operator &(const CAutoArray<ULONG>& v)
//{
//	WriteArrayT(m_pInternalBuf, v);
//	return *this;
//}

#else

SpBuffer& SpBuffer::operator &(CSimpleString16Bit& v)
{
    DoT(m_pInternalBuf, m_iMode, v);
    return *this;
}

SpBuffer& SpBuffer::operator &(CAutoArray<CSimpleString16Bit>& v)
{
    DoArrayT(m_pInternalBuf, m_iMode, v);
    return *this;
}

SpBuffer& SpBuffer::operator &(const CSimpleString16Bit& v)
{
    WriteT(m_pInternalBuf, v);
    return *this;
}

SpBuffer& SpBuffer::operator &(const CAutoArray<CSimpleString16Bit>& v)
{
    WriteArrayT(m_pInternalBuf, v);
    return *this;
}




#endif //_WIN32

CAutoBuffer SpBuffer::ToBuffer()
{
	CAutoBuffer Buf;
	int size = iobuffer_get_length(m_pInternalBuf);
	Buf.Init(size);
	if (size) {
		memcpy(&Buf[0], iobuffer_data(m_pInternalBuf, 0), size);
	}
	return Buf;
}

CBlob SpBuffer::ToBlob()
{
	CBlob blob;
	int size = iobuffer_get_length(m_pInternalBuf);
	blob.m_bManaged = true;
	blob.m_iLength = size;
	if (size) {
		blob.m_pData = new char[size];
		memcpy(blob.m_pData, iobuffer_data(m_pInternalBuf, 0), size);
	}
	return blob;
}


SPBASE_API ErrorCodeEnum SpExtractClassFunctionName(const char *pszParam, CSimpleStringA &strClassName, CSimpleStringA &strFunctionName)
{
	if (!pszParam)
		return Error_Null;
	const char *p = strstr(pszParam, "::");
	if (p) {
		if (p == pszParam) {
			// "::func"
			strClassName = "";
		} else {
			// "class::func"
			strClassName = CSimpleStringA(pszParam, p - pszParam);
		}
		p += 2;
		if (*p == '\0') {
			// "class::"
			strFunctionName = "";
		} else {
			// "class::func"
			strFunctionName = p;
		}
	} else {
		// "class"
		strClassName = pszParam;
		strFunctionName = pszParam;
	}
	return Error_Succeed;
}

#define ENT_ENUM_MAP(name) case EntityState_##name: return "[" #name "]"; break;

SPBASE_API LPCTSTR SpStrEntityState(const EntityStateEnum state)
{
	switch (state) {
		ENT_ENUM_MAP(NoStart)
		ENT_ENUM_MAP(Starting)
		ENT_ENUM_MAP(Idle)
		ENT_ENUM_MAP(Busy)
		ENT_ENUM_MAP(Pause)
		ENT_ENUM_MAP(UnLoading)
		ENT_ENUM_MAP(Lost)
		ENT_ENUM_MAP(Close)
		ENT_ENUM_MAP(Killed)
		ENT_ENUM_MAP(Passed)
		ENT_ENUM_MAP(Failed)
	default:
		break;
	}
	return "Unknown";
}

#undef ENT_ENUM_MAP
#define ENT_ENUM_MAP(name) case CloseCause_##name: return #name; break;

SPBASE_API LPCTSTR SpStrCloseCause(const EntityCloseCauseEnum cause)
{
	switch (cause) {
		ENT_ENUM_MAP(Self)
		ENT_ENUM_MAP(Other)
		ENT_ENUM_MAP(Lost)
		ENT_ENUM_MAP(Dragged)
		ENT_ENUM_MAP(ShellQuit)
		ENT_ENUM_MAP(Crash)
	default:
		break;
	}
	return "Unknown";
}

#undef ENT_ENUM_MAP
#define ENT_ENUM_MAP(name) case RebootTrigger_##name: return #name; break;

SPBASE_API LPCTSTR SpStrRebootTrigger(const RebootTriggerEnum trigger)
{
	switch (trigger) {
		ENT_ENUM_MAP(Unknown)
		ENT_ENUM_MAP(Period)
		ENT_ENUM_MAP(FrameUpgrade)
		ENT_ENUM_MAP(OSUpgrade)
		ENT_ENUM_MAP(RollBack)
		ENT_ENUM_MAP(FailLoad)
		ENT_ENUM_MAP(Resource)
		ENT_ENUM_MAP(RunExcepition)
		ENT_ENUM_MAP(RunDead)
		ENT_ENUM_MAP(Attacked)
		ENT_ENUM_MAP(Powerdown)
		ENT_ENUM_MAP(Repaired)
		ENT_ENUM_MAP(ManualLocal)
		ENT_ENUM_MAP(ManualRemove)
		ENT_ENUM_MAP(Unsubscribe)
		ENT_ENUM_MAP(DeadForever)
	default:
		break;
	}
	return "UnRecorded";
}

#undef ENT_ENUM_MAP
#define ENT_ENUM_MAP(name) case RebootWay_##name: return #name; break;

SPBASE_API LPCTSTR SpStrRebootWay(const RebootWayEnum way)
{
	switch (way) {
		ENT_ENUM_MAP(Unknown)
			ENT_ENUM_MAP(Framework)
			ENT_ENUM_MAP(OS)
			ENT_ENUM_MAP(Power)
	default:
		break;
	}
	return "UnRecorded";
}

#undef ENT_ENUM_MAP
#define ENT_ENUM_MAP(name) case AppBootState_##name: return #name; break;

SPBASE_API LPCTSTR SpStrAppBootState(const AppBootStateEnum state)
{

	static char content[128];

	switch (state) {
		ENT_ENUM_MAP(Init)
		ENT_ENUM_MAP(StartEntity)
		ENT_ENUM_MAP(CallAccessAuth)
		ENT_ENUM_MAP(FirstEnterMainPage)
	default:
		sprintf(content, "UnRecorded(%d)", (int)state);
		break;
	}
	return content;
}

SPBASE_API MachineTypeEnum SpStr2MachineType(const CSimpleStringA& strMachineType)
{
	MachineTypeEnum machineType(RVC_Unknown);
	if (!strMachineType.IsNullOrEmpty()) {
		if (_stricmp(strMachineType, "RVC.Stand2S") == 0) {
			machineType = RVC_Stand2S;
		}
		else if (_stricmp(strMachineType, "RVC.Stand1SPlus") == 0) {
			machineType = RVC_Stand1SPlus;
		}
		else if (_stricmp(strMachineType, "RVC.CardStore") == 0) {
			machineType = RVC_CardStore;
		}
		else if (_stricmp(strMachineType, "RVC.CardPrinter") == 0) {
			machineType = RVC_CardPrinter;
		}
	}
	return machineType;
}

#undef ENT_ENUM_MAP