简单之特征检测缓存设计

    在开发中，很多人都在为效率，精确与安全方面做最大的平衡，但结果往往不如人意，没有完美的解决方案，只有针对性的对象与方法，不同的方向有不同的需要，过于追求完美最终受伤的还是自己。想做一个高效但精确度较低的简单特征检测设计，感觉到了利弊的矛盾，但凡是都值得一试！

#define MAX_CHATIC_SIZE (256)

//单个缓存方案
typedef struct _BUNCH_CACHE {
	bool bOwn;
	bool bPUnit[MAX_CHATIC_SIZE];
} BUNCH_CACHE,*PBUNCH_CACHE;

typedef struct _CHARACTERISTIC_CACHE {
	bool bOwn;
	BUNCH_CACHE sBCache[MAX_CHATIC_SIZE];
} CHARACTERISTIC_CACHE, *PCHARACTERISTIC_CACHE;

//多个缓存方案
typedef struct _GROUP_CHARACTERISTIC_CACHE {
	CHARACTERISTIC_CACHE sCCache[MAX_CHATIC_SIZE];
} GROUP_CHARACTERISTIC_CACHE, *PGROUP_CHARACTERISTIC_CACHE;

/*
* 通过云计算统计出目前最流行的特征数据,特征数据最大长度为256个字节;
* 缓存支持65536个特征数据,虽然精确率较低但同时也有提高精确降低效率的方法;
*/


//初始化准备;
inline PCHARACTERISTIC_CACHE _cdecl ChaticCache_Init(void)
{
	PCHARACTERISTIC_CACHE lpChaticCache = (PCHARACTERISTIC_CACHE)malloc((sizeof(CHARACTERISTIC_CACHE) * MAX_CHATIC_SIZE));

	if (NULL == lpChaticCache)
		return NULL;

	memset(lpChaticCache, 0, (sizeof(CHARACTERISTIC_CACHE) * MAX_CHATIC_SIZE));

	return (lpChaticCache);
}

inline void _cdecl ChaticCache_Free(PCHARACTERISTIC_CACHE * lpChaticCache)
{
	if (*lpChaticCache != NULL)
	{
		free(*lpChaticCache);
		*lpChaticCache = NULL;
	}
}

enum _CHATIC_CACHE_RETURN {
	Error_Succeed,
	Error_Param,
	Error_Fail
};

//充填缓存特征数据;
inline int _cdecl ChaticCache_Fill(PCHARACTERISTIC_CACHE lpChaticCache, const UCHAR * lpFillData, size_t uCount)
{
	register USHORT uByteIndex = 0U;
	register UCHAR uLByteIndex = 0U;

	if (NULL == lpChaticCache || NULL == lpFillData || uCount > MAX_CHATIC_SIZE)
		return Error_Param;

	uLByteIndex = *lpFillData;

	if (!(lpChaticCache[*lpFillData].bOwn))
		lpChaticCache[*lpFillData].bOwn = true;

	for (uByteIndex += 1U; uByteIndex < uCount; ++uByteIndex)
	{
		if (!(lpChaticCache[*lpFillData].sBCache[lpFillData[uByteIndex]].bOwn))
			lpChaticCache[*lpFillData].sBCache[lpFillData[uByteIndex]].bOwn = true;
		if (!(lpChaticCache[*lpFillData].sBCache[lpFillData[uByteIndex]].bPUnit[uLByteIndex]))
			lpChaticCache[*lpFillData].sBCache[lpFillData[uByteIndex]].bPUnit[uLByteIndex] = true;
		uLByteIndex = lpFillData[uByteIndex];
	}
	return Error_Succeed;
}

//比较缓存特征数据;
inline int _cdecl ChaticCache_Cmps(PCHARACTERISTIC_CACHE lpChaticCache, const UCHAR * lpCmpsData, size_t uCount)
{
	register USHORT uByteIndex = 0U;
	register UCHAR uLByteIndex = 0U;

	UCHAR uExcluData[MAX_CHATIC_SIZE] = { 0U };
	const size_t uMinChaticCodeSize = uCount / sizeof(DWORD); //提高精确性,对抗外部干扰[特征码重复数据量较少,作为一种规范];

	if (NULL == lpChaticCache || NULL == lpCmpsData || uCount > MAX_CHATIC_SIZE)
		return Error_Param;

	if (!(lpChaticCache[*lpCmpsData].bOwn))
		return Error_Fail;
	else
		uLByteIndex = *lpCmpsData;

	for (uByteIndex += 1U; uByteIndex < uCount; ++uByteIndex)
	{
		if ((++uExcluData[uLByteIndex]) > uMinChaticCodeSize)
			return Error_Fail;
		else if (!(lpChaticCache[*lpCmpsData].sBCache[lpCmpsData[uByteIndex]].bOwn))
			return Error_Fail;
		else if (!(lpChaticCache[*lpCmpsData].sBCache[lpCmpsData[uByteIndex]].bPUnit[uLByteIndex]))
			return Error_Fail;
		else
			uLByteIndex = lpCmpsData[uByteIndex];
	}
	return Error_Succeed;
}