AMPS:哈希表源码解读

最新推荐文章于 2016-06-26 16:07:05 发布
最新推荐文章于 2016-06-26 16:07:05 发布
阅读量3.4k 收藏
点赞数
分类专栏： C/C++ 消息中间件 AMPS源码解读
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dyx1024/article/details/8526518
版权

  Hash表也是一种常用的数据结构，AMPS中的Hash表并不是给使用者提供一个散列函数，而是仅提供一个创建和维护Hash表这样一个结构的一组函数，针对不同的应用或者数据，由用户自己定义其要使用的散列函数，AMPS中，Hash表组成结构是如下的拉链式结构。


下面看看AMPS中对Hash操作的代码：

AMPS_Hash.h

#ifndef __HEADER_AMPS_HASH_H
#define __HEADER_AMPS_HASH_H

#ifdef __cplusplus
extern "C" {
#endif

#include "AMPS_API.h"
#include "AMPS_Defines.h"
#include "AMPS_LinkList.h"

//#define AMPS_HASH_TABLE_KEY_SIZE		1009    // Prime Nos : 1009, 11003, 11027, 50021, 50023, 100019

typedef struct _HASHTableEntry  	t_HASHTableEntry;
typedef struct _HASHTableNode       t_HASHTableNode;
typedef struct _HASHTable           t_HASHTable;
typedef struct _HASHTableUserData   t_HASHTableUserData;

typedef int(*HashTable_InsertCallback)(void* r_pvAMPSContext, void* r_pvHASHTable, void* r_pvData, t_AMPSHashTableKey* r_poHASHKey);
typedef void*(*HashTable_SearchCallback)(void* r_pvAMPSContext, void* r_pvHASHTable, t_AMPSHashTableKey* r_poHASHKey);
typedef int(*HashTable_DeleteCallback)(void* r_pvAMPSContext, void* r_pvHASHTable, t_AMPSHashTableKey* r_poHASHKey);

struct _HASHTableEntry
{
    t_AMPSDList* poDListOfHashTableNode;    //list of t_HASHTableNode
};

/*Hash表结点结构*/
struct _HASHTableNode
{
    t_AMPSSList*                poSListNodeBackPtr; /*具有相同key值的各数据节点*/
    void*						pvAMPSContext;
    t_AMPSHashTableKey			oHASHKey;
    int							nHashTableIndex;
    void*						pvData;             //Node specific pvData
};

/*Hash表结构*/
struct _HASHTable
{
    t_HASHTableEntry*       		poHASHTableEntry; /*存放各节点的值*/

    int                             nHashTableSize; /*结点个数*/

    //variable functions
    AMPS_HashTableHashCallback      pfAMPS_HashTableHashCallback; /*散列函数*/
    HashTable_InsertCallback        pfHashTable_InsertCallback;   
    HashTable_SearchCallback        pfHashTable_SearchCallback;
    HashTable_DeleteCallback        pfHashTable_DeleteCallback;
};

struct _HASHTableUserData
{
	AMPS_HashTableProcessNodeDataCallback	pfAMPS_HashTableProcessNodeDataCallback;
	AMPS_APP_HANDLE						hAMPS_APP_HANDLE;
};

void* HashTable_Create(void* r_pvAMPSContext, int r_SizeOfHashTable, AMPS_HashTableHashCallback r_pfAMPS_HashTableHashCallback);
void HashTable_Delete (void* r_pvAMPSContext, void* r_pvHASHTable);
void HashTable_DeleteAllEntries(void* r_pvAMPSContext, void* r_pvHASHTable, AMPS_HashTableProcessNodeDataCallback r_pfAMPS_HashTableProcessNodeDataCallback, AMPS_APP_HANDLE r_hAMPS_APP_HANDLE);

void HashTable_TraverseAllEntries(void* r_pvAMPSContext, void* r_pvHASHTable, AMPS_HashTableProcessNodeDataCallback r_pfAMPS_HashTableProcessNodeDataCallback, AMPS_APP_HANDLE r_hAMPS_APP_HANDLE);
void HashTable_ProcessNodeData(void* r_pvListNodeData, void* r_pvArg);

unsigned int HashTable_Main(void* r_pvAMPSContext, void* r_pvHASHTable, t_AMPSHashTableKey* r_poHASHKey);

int HashTable_Insert(void* r_pvAMPSContext, void* r_pvHASHTable, void* r_pvData, t_AMPSHashTableKey* r_poHASHKey);
int HashTable_RemoveByHandle(void* r_pvAMPSContext, void* r_pvHASHTable, int r_nHandle);
int HashTable_RemoveByKey(void* r_pvAMPSContext, void* r_pvHASHTable, t_AMPSHashTableKey* r_poHASHKey);
void* HashTable_Search(void* r_pvAMPSContext, void* r_pvHASHTable, t_AMPSHashTableKey* r_poHASHKey);
void* HashTable_LookupByHandleAndHashKey(void* r_pvAMPSContext, void* r_pvHASHTable, t_AMPSHashTableKey* r_poHASHKey, int r_nHandle);
void* HashTable_LookupByHandle(void* r_pvAMPSContext, void* r_pvHASHTable, int r_nHandle);
void* HashTable_SearchData (void* r_pvAMPSContext, t_AMPSDList* r_pDList, t_AMPSHashTableKey* r_poHASHKey);

void* HashTable_CreateAndAppendNode (void* r_pvAMPSContext, t_AMPSDList* r_poDList, void* r_pvData, t_AMPSHashTableKey* r_poHASHKey, int r_nHashTableIndex);

int HashTable_FreeNodeData (void** r_ppvHASHTableNode);
int HashTable_CompareNodeKey(void* r_pvHASHKey, void* r_pvHashTableNode);
void HashTable_FreeNodeDataEx(void* r_pvListNodeData, void* r_pvArg);

unsigned int HashTable_StringSum (void* r_pvAMPSContext, void* r_pvHASHTable, t_AMPSHashTableKey* r_poHASHKey);
unsigned int HashTable_Universal (void* r_pvAMPSContext, void* r_pvHASHTable, t_AMPSHashTableKey* r_poHASHKey);
unsigned int HashTable_HashFunc1(void* r_pvAMPSContext, void* r_pvHASHTable, t_AMPSHashTableKey* r_poHASHKey);


#ifdef __cplusplus
}
#endif

#endif //__HEADER_AMPS_HASH_H

AMPS_Hash.c 

/*****************************************************************
文件名称: AMPS_Hash.c
功能描述: 拉链式存储的Hash表操作函数库

*****************************************************************/


#include "AMPS_Core.h"
#include "AMPS_Defines.h"
#include "AMPS_MemMgt.h"
#include "AMPS_Hash.h"
#include "AMPS_LinkList.h"

/*****************************************************************
函数名称: HashTable_Create
功能描述: 建立Hash表
入参::
      void* r_pvAMPSContext AMPS应用上下文
      int r_nSizeOfHashTable Hash表总大小
      AMPS_HashTableHashCallback r_pfAMPS_HashTableHashCallback 回调函数
出参:
      
返回值:
      void* 创建的Hash表

*****************************************************************/
void* HashTable_Create(void* r_pvAMPSContext, int r_nSizeOfHashTable, AMPS_HashTableHashCallback r_pfAMPS_HashTableHashCallback)
{
    t_HASHTable* poHASHTable = NULL;
    int nCounter = 0;

    TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Entering.\n");

    poHASHTable = AMPS_InternalMalloc(sizeof (t_HASHTable));
    if (NULL == poHASHTable)
    {
        return NULL;
    }

    poHASHTable->poHASHTableEntry = AMPS_InternalMalloc(sizeof(t_HASHTableEntry) * r_nSizeOfHashTable);
    if (NULL == poHASHTable->poHASHTableEntry)
    {
        AMPS_InternalFree (poHASHTable);
        return NULL;
    }

    poHASHTable->nHashTableSize = r_nSizeOfHashTable;

    if (NULL == r_pfAMPS_HashTableHashCallback)
    {
        poHASHTable->pfAMPS_HashTableHashCallback = HashTable_HashFunc1;
    } else
    {
        poHASHTable->pfAMPS_HashTableHashCallback = r_pfAMPS_HashTableHashCallback;
    }

    /*结点存放在双向链表中*/
    for (; nCounter < poHASHTable->nHashTableSize; nCounter++)
    {
        if (NULL == DList_Init (&poHASHTable->poHASHTableEntry[nCounter].poDListOfHashTableNode))
        {
            return NULL;
        }
    }

    TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Leaving\n");

    return poHASHTable;
}

/*****************************************************************
函数名称: HashTable_Delete
功能描述: 释放Hash表
入参::
      void* r_pvAMPSContext AMPS应用上下文
      void* r_pvHASHTable Hash表句柄     
出参:
      t_AMPSDList* 操作后的链表
返回值:
      NA

*****************************************************************/
void HashTable_Delete(void* r_pvAMPSContext, void* r_pvHASHTable)
{
    t_HASHTable* poHASHTable = (t_HASHTable*)r_pvHASHTable;
    int nCounter = 0;

    TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Entering.\n");
    for (; nCounter < poHASHTable->nHashTableSize; nCounter++)
    {
        DList_Free(&poHASHTable->poHASHTableEntry[nCounter].poDListOfHashTableNode, HashTable_FreeNodeData);
    }

    AMPS_InternalFree(poHASHTable->poHASHTableEntry); 
    AMPS_InternalFree (poHASHTable);      

    TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Leaving\n");
}

/*****************************************************************
函数名称: HashTable_TraverseAllEntries
功能描述: 遍历并处理Hash表各结点
入参::
      void* r_pvAMPSContext AMPS应用上下文
      void* r_pvHASHTable Hash表句柄  
      AMPS_HashTableProcessNodeDataCallback r_pfAMPS_HashTableProcessNodeDataCallback
出参:
      t_AMPSDList* 操作后的链表
返回值:
      NA

*****************************************************************/
void HashTable_TraverseAllEntries(void* r_pvAMPSContext, void* r_pvHASHTable, AMPS_HashTableProcessNodeDataCallback r_pfAMPS_HashTableProcessNodeDataCallback, AMPS_APP_HANDLE r_hAMPS_APP_HANDLE)
{
	t_HASHTable* poHASHTable = (t_HASHTable*)r_pvHASHTable;
	int nCounter = 0;

	TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Entering.\n");

	if((NULL != r_pfAMPS_HashTableProcessNodeDataCallback) || (NULL != r_hAMPS_APP_HANDLE))
	{
		t_HASHTableUserData oHASHTableUserData;

		oHASHTableUserData.hAMPS_APP_HANDLE = r_hAMPS_APP_HANDLE;
		oHASHTableUserData.pfAMPS_HashTableProcessNodeDataCallback = r_pfAMPS_HashTableProcessNodeDataCallback;

		for (; nCounter < poHASHTable->nHashTableSize; nCounter++)
		{
			DList_Traverse(poHASHTable->poHASHTableEntry[nCounter].poDListOfHashTableNode, HashTable_ProcessNodeData, &oHASHTableUserData);
		}
	}
}

/*****************************************************************
函数名称: HashTable_ProcessNodeData
功能描述: 处理各节点
入参::
      void* r_pvListNodeData 结点数据
      void* r_pvArg 参数

出参:
      
返回值:
      NA

*****************************************************************/
void HashTable_ProcessNodeData(void* r_pvListNodeData, void* r_pvArg)
{
	t_HASHTableNode* poHASHTableNode = r_pvListNodeData;
	t_HASHTableUserData* poHASHTableUserData = r_pvArg;
	t_AMPSContext* poAMPSContext = poHASHTableNode->pvAMPSContext;

	TRACE(HASH_TRACE_ID(poAMPSContext), AMPS_TRACE_LEVEL_INFO, "Entering.\n");

	poHASHTableUserData->pfAMPS_HashTableProcessNodeDataCallback(poAMPSContext, poHASHTableUserData->hAMPS_APP_HANDLE, poHASHTableNode->pvData);

	TRACE( HASH_TRACE_ID(poAMPSContext), AMPS_TRACE_LEVEL_INFO, "Leaving\n");
}

/*****************************************************************
函数名称: HashTable_DeleteAllEntries
功能描述: 处理各节点
入参::
      void* r_pvAMPSContext 应用上下文
      void* r_pvHASHTable hash表
      AMPS_HashTableProcessNodeDataCallback r_pfAMPS_HashTableProcessNodeDataCallback
      AMPS_APP_HANDLE r_hAMPS_APP_HANDLE 应用句柄

出参:
      
返回值:
      NA

*****************************************************************/
void HashTable_DeleteAllEntries(void* r_pvAMPSContext, void* r_pvHASHTable, AMPS_HashTableProcessNodeDataCallback r_pfAMPS_HashTableProcessNodeDataCallback, AMPS_APP_HANDLE r_hAMPS_APP_HANDLE)
{
	t_HASHTable* poHASHTable = (t_HASHTable*)r_pvHASHTable;
	int nCounter = 0;

	TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Entering.\n");

	if((NULL == r_pfAMPS_HashTableProcessNodeDataCallback) || (NULL == r_hAMPS_APP_HANDLE))
	{
		for (; nCounter < poHASHTable->nHashTableSize; nCounter++)
		{
            /*释放并初始化各结点*/
			DList_Free(&poHASHTable->poHASHTableEntry[nCounter].poDListOfHashTableNode, HashTable_FreeNodeData);
			if (NULL == DList_Init (&poHASHTable->poHASHTableEntry[nCounter].poDListOfHashTableNode))
			{
				TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_ERROR,"unable to re-create node list\n"); 
				return;
			}
		}
	}
	else
	{
		t_HASHTableUserData oHASHTableUserData;

		oHASHTableUserData.hAMPS_APP_HANDLE = r_hAMPS_APP_HANDLE;
		oHASHTableUserData.pfAMPS_HashTableProcessNodeDataCallback = r_pfAMPS_HashTableProcessNodeDataCallback;

		for (; nCounter < poHASHTable->nHashTableSize; nCounter++)
		{
            /*释放前处理结点*/
			DList_FreeEx(&poHASHTable->poHASHTableEntry[nCounter].poDListOfHashTableNode, HashTable_FreeNodeDataEx, &oHASHTableUserData);
			if (NULL == DList_Init(&poHASHTable->poHASHTableEntry[nCounter].poDListOfHashTableNode))
			{
				TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_ERROR,"unable to re-create node list\n"); 
				return;
			}
		}
	}
}

/*****************************************************************
函数名称: HashTable_FreeNodeData
功能描述: 释放节点
入参::
      void** r_ppvHASHTableNode 要释放的结点


出参:
      
返回值:
      int

*****************************************************************/
int HashTable_FreeNodeData(void** r_ppvHASHTableNode)
{
    t_HASHTableNode* poHASHTableNode = (t_HASHTableNode*)(*r_ppvHASHTableNode);
    //t_AMPSContext* poAMPSContext = (t_AMPSContext*)poHASHTableNode->pvAMPSContext;

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Entering.\n");

    memset(poHASHTableNode->oHASHKey.puchKey, 0, poHASHTableNode->oHASHKey.unKeyLength);
    AMPS_InternalFree(poHASHTableNode);

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Leaving\n");

    return AMPS_SUCCESS;
}

/*****************************************************************
函数名称: HashTable_FreeNodeDataEx
功能描述: 释放节点
入参::
      void** r_ppvHASHTableNode 要释放的结点
      void* r_pvArg 参数

出参:
      
返回值:
      int

*****************************************************************/
void HashTable_FreeNodeDataEx(void* r_pvListNodeData, void* r_pvArg)
{
	t_HASHTableNode* poHASHTableNode = r_pvListNodeData;
	t_HASHTableUserData* poHASHTableUserData = r_pvArg;
	t_AMPSContext* poAMPSContext = poHASHTableNode->pvAMPSContext;

	TRACE(HASH_TRACE_ID(poAMPSContext), AMPS_TRACE_LEVEL_INFO, "Entering.\n");

	poHASHTableUserData->pfAMPS_HashTableProcessNodeDataCallback(poAMPSContext, poHASHTableUserData->hAMPS_APP_HANDLE, poHASHTableNode->pvData);
	AMPS_InternalFree(poHASHTableNode);

	TRACE( HASH_TRACE_ID(poAMPSContext), AMPS_TRACE_LEVEL_INFO, "Leaving\n");
}


/*****************************************************************
函数名称: HashTable_FreeNodeDataEx
功能描述: 插入结点
入参:
      void* r_pvAMPSContext AMPS应用上下文
      void* r_pvHASHTable   Hash指针
      void* r_pvData        结点内容
      t_AMPSHashTableKey* r_poHASHKey 索引值

出参:
      
返回值:
      int

*****************************************************************/
int HashTable_Insert(void* r_pvAMPSContext, void* r_pvHASHTable, void* r_pvData, t_AMPSHashTableKey* r_poHASHKey)
{
    t_AMPSContext* poAMPSContext = (t_AMPSContext*)r_pvAMPSContext;
    t_HASHTable* poHASHTable = (t_HASHTable*)r_pvHASHTable;
    void* pvHASHTableNode = NULL;
    unsigned int nHashTableIndex = 0;

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Entering.\n");

    /*得到一个位置*/
    nHashTableIndex = HashTable_Main(poAMPSContext, poHASHTable, r_poHASHKey);
    if (0 > nHashTableIndex)
    {
        return AMPS_INVALID_HANDLE;
    }

    /*第一个结点*/
    if (poHASHTable->poHASHTableEntry[nHashTableIndex].poDListOfHashTableNode->poAMPSSListHead == NULL)
    {
        pvHASHTableNode = HashTable_CreateAndAppendNode (poAMPSContext, poHASHTable->poHASHTableEntry[nHashTableIndex].poDListOfHashTableNode, r_pvData, r_poHASHKey, nHashTableIndex);
        if (NULL == pvHASHTableNode)
        {
            return AMPS_INVALID_HANDLE;
        }
    } else
    {
        //DList_Search will return NULL(last poAMPSSListNext pointer) if table entry deos not exist
        if (NULL == DList_Search(poHASHTable->poHASHTableEntry[nHashTableIndex].poDListOfHashTableNode, HashTable_CompareNodeKey, r_poHASHKey))
        {
            pvHASHTableNode = HashTable_CreateAndAppendNode (poAMPSContext, poHASHTable->poHASHTableEntry[nHashTableIndex].poDListOfHashTableNode, r_pvData, r_poHASHKey, nHashTableIndex);
            if (NULL == pvHASHTableNode)
            {
                return AMPS_INVALID_HANDLE;
            }
        } else
        {
            //ERROR HANDLING
            TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_WARNING, "Entery already exist.\n");
            return AMPS_INVALID_HANDLE;
        }
    }

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Leaving\n");

    return((int)pvHASHTableNode);
}

/*****************************************************************
函数名称: HashTable_CreateAndAppendNode
功能描述: 插入结点
入参:
      void* r_pvAMPSContext AMPS应用上下文
      t_AMPSDList* r_poDList, hash表中的结点链表
      void* r_pvData, 要追加的结点数据
      t_AMPSHashTableKey* r_poHASHKey 要追加的结点的k值
      int r_nHashTableIndex index

出参:
      
返回值:
      int

*****************************************************************/
void* HashTable_CreateAndAppendNode(void* r_pvAMPSContext, t_AMPSDList* r_poDList, void* r_pvData, t_AMPSHashTableKey* r_poHASHKey, int r_nHashTableIndex)
{
    //t_AMPSContext* poAMPSContext = (t_AMPSContext*)r_pvAMPSContext;
    t_AMPSSList* poSListNode = NULL;
    t_HASHTableNode* poHASHTableNode = NULL;

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Entering.\n");

    /*创建结点*/
	poHASHTableNode = AMPS_InternalMalloc (sizeof(t_HASHTableNode));
    if (NULL == poHASHTableNode)
    {
        return NULL;
    }

    /*结点赋值*/
    poHASHTableNode->pvAMPSContext = r_pvAMPSContext;
    poHASHTableNode->pvData = r_pvData;
    poHASHTableNode->nHashTableIndex = r_nHashTableIndex;
    if (AMPS_HASH_TABLE_KEY_SIZE < r_poHASHKey->unKeyLength)
    {
        AMPS_InternalFree(poHASHTableNode);
        return NULL;
    }
    strncpy((char*)poHASHTableNode->oHASHKey.puchKey, (char*)r_poHASHKey->puchKey, r_poHASHKey->unKeyLength);
    poHASHTableNode->oHASHKey.unKeyLength = r_poHASHKey->unKeyLength;

    poSListNode = (t_AMPSSList*)AMPS_InternalMalloc(sizeof(t_AMPSSList));
    if (NULL == poSListNode)
    {
        memset(poHASHTableNode->oHASHKey.puchKey, 0, poHASHTableNode->oHASHKey.unKeyLength);
        AMPS_InternalFree(poHASHTableNode);
        return NULL;
    }
    poHASHTableNode->poSListNodeBackPtr = poSListNode;

    /*将结点挂在Hash中的双向链表中*/
    DList_PrependGivenNode(r_poDList, poHASHTableNode, poSListNode);

	/*if(r_poDList->uchCount > 15)
		printf("r_poDList->uchCount %d\n", r_poDList->uchCount);*/
	
    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Leaving\n");

    return poHASHTableNode;
}


/*****************************************************************
函数名称: HashTable_RemoveByHandle
功能描述: 删除结点
入参:
      void* r_pvAMPSContext AMPS应用上下文
      void* r_pvHASHTable
      int r_nHandle


出参:
      
返回值:
      int

*****************************************************************/
int HashTable_RemoveByHandle(void* r_pvAMPSContext, void* r_pvHASHTable, int r_nHandle)
{
    //t_AMPSContext* poAMPSContext = (t_AMPSContext*)r_pvAMPSContext;
    t_HASHTable* poHashTable = (t_HASHTable*)r_pvHASHTable;
    //这句是错的吧
    t_HASHTableNode* poHASHTableNode = (t_HASHTableNode*)r_nHandle; 
    t_AMPSSList* poSListNode = poHASHTableNode->poSListNodeBackPtr;

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Entering.\n");

    if (AMPS_SUCCESS != DList_Remove(&poHashTable->poHASHTableEntry[poHASHTableNode->nHashTableIndex].poDListOfHashTableNode, poSListNode, HashTable_FreeNodeData))
    {
        return AMPS_ERROR_FAILURE;
    }

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Leaving\n");

    return AMPS_SUCCESS;
}

/*****************************************************************
函数名称: HashTable_RemoveByKey
功能描述: 删除结点
入参:
      void* r_pvAMPSContext AMPS应用上下文
      void* r_pvHASHTable
      t_AMPSHashTableKey* r_poHASHKey


出参:
      
返回值:
      int

*****************************************************************/
int HashTable_RemoveByKey(void* r_pvAMPSContext, void* r_pvHASHTable, t_AMPSHashTableKey* r_poHASHKey)
{
    t_AMPSContext* poAMPSContext = (t_AMPSContext*)r_pvAMPSContext;
    t_HASHTable* poHashTable = (t_HASHTable*)r_pvHASHTable;
    t_AMPSSList* poSListNode = NULL;
    unsigned int unHashTableIndex = 0;      

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Entering.\n");

    unHashTableIndex = HashTable_Main(poAMPSContext, poHashTable, r_poHASHKey);

    poSListNode = DList_Search(poHashTable->poHASHTableEntry[unHashTableIndex].poDListOfHashTableNode, HashTable_CompareNodeKey, r_poHASHKey);
    if (NULL != poSListNode)
    {
        return(DList_Remove(&poHashTable->poHASHTableEntry[unHashTableIndex].poDListOfHashTableNode, poSListNode, HashTable_FreeNodeData));
    } else
    {
        return AMPS_ERROR_FAILURE;
    }

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Leaving\n");

    return AMPS_SUCCESS;
}

/*****************************************************************
函数名称: HashTable_Search
功能描述: 查找结点
入参:
      void* r_pvAMPSContext AMPS应用上下文
      void* r_pvHASHTable
      t_AMPSHashTableKey* r_poHASHKey


出参:
      
返回值:
      int

*****************************************************************/

void* HashTable_Search(void* r_pvAMPSContext, void* r_pvHASHTable, t_AMPSHashTableKey* r_poHASHKey)
{
    t_AMPSContext* poAMPSContext = (t_AMPSContext*)r_pvAMPSContext;
    t_HASHTable* poHashTable = (t_HASHTable*)r_pvHASHTable;
    unsigned int unHashTableIndex = 0;
    t_AMPSSList* poSListNode = NULL;

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Entering.\n");

    unHashTableIndex = HashTable_Main(r_pvAMPSContext, poHashTable, r_poHASHKey); //retrieve index for Node

    //Search the indexed list
    if (NULL != poHashTable->poHASHTableEntry[unHashTableIndex].poDListOfHashTableNode)
    {
        poSListNode = poHashTable->poHASHTableEntry[unHashTableIndex].poDListOfHashTableNode->poAMPSSListHead;

        if (NULL == poSListNode)
        {
            return NULL;
        }

        /*找到*/
        //if required pvData is in the first node?
        if (AMPS_SUCCESS == HashTable_CompareNodeKey (r_poHASHKey, poSListNode->pvData))
        {
            return((t_HASHTableNode*)poSListNode->pvData)->pvData;
        }
        //proceed to perform list search
        return(HashTable_SearchData (poAMPSContext, poHashTable->poHASHTableEntry[unHashTableIndex].poDListOfHashTableNode, r_poHASHKey));
    }

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Leaving.\n");

    return NULL;
}


/*****************************************************************
函数名称: HashTable_LookupByHandleAndHashKey
功能描述: 查找结点(使用handle和key)
入参:
      void* r_pvAMPSContext AMPS应用上下文
      void* r_pvHASHTable
      t_AMPSHashTableKey* r_poHASHKey


出参:
      
返回值:
      int

*****************************************************************/
void* HashTable_LookupByHandleAndHashKey(void* r_pvAMPSContext, void* r_pvHASHTable, t_AMPSHashTableKey* r_poHASHKey, int r_nHandle)
{
    //t_AMPSContext* poAMPSContext = (t_AMPSContext*)r_pvAMPSContext;
    //t_HASHTable* poHashTable = (t_HASHTable*)r_pvHASHTable;
    t_HASHTableNode* poHASHTableNode = (t_HASHTableNode*)r_nHandle;

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Entering.\n");

    if (AMPS_SUCCESS == HashTable_CompareNodeKey (r_poHASHKey, poHASHTableNode))
    {
        return(poHASHTableNode->pvData);
    }

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Leaving.\n");

    return NULL;
}

/*****************************************************************
函数名称: HashTable_LookupByHandle
功能描述: 查找结点数据(使用handle)
入参:
      void* r_pvAMPSContext AMPS应用上下文
      void* r_pvHASHTable
      t_AMPSHashTableKey* r_poHASHKey


出参:
      
返回值:
      int

*****************************************************************/
void* HashTable_LookupByHandle(void* r_pvAMPSContext, void* r_pvHASHTable, int r_nHandle)
{
    //t_AMPSContext* poAMPSContext = (t_AMPSContext*)r_pvAMPSContext;
    //t_HASHTable* poHashTable = (t_HASHTable*)r_pvHASHTable;
    //真没有理解
    t_HASHTableNode* poHASHTableNode = (t_HASHTableNode*)r_nHandle;
    void* pvData = NULL;

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Entering.\n");

    pvData = poHASHTableNode->pvData;

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Leaving.\n");

    return pvData;
}

/*****************************************************************
函数名称: HashTable_CompareNodeKey
功能描述: 比较指定的key是否与结点内容匹配
入参:
      void* r_pvHASHKey
      void* r_pvHashTableNode


出参:
      
返回值:
      int

*****************************************************************/
int HashTable_CompareNodeKey(void* r_pvHASHKey, void* r_pvHashTableNode) 
{
    t_AMPSHashTableKey* poHASHKey = (t_AMPSHashTableKey*)r_pvHASHKey;
    t_HASHTableNode* poHASHTableNode = (t_HASHTableNode*)r_pvHashTableNode;

    //t_AMPSContext* poAMPSContext = (t_AMPSContext*)poHASHTableNode->pvAMPSContext;

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Entering.\n");

	//if(poHASHKey->unKeyLength == poHASHTableNode->oHASHKey.unKeyLength)
	{
		if (0 == SAPI_StrnCaseCMP((char*)poHASHKey->puchKey, (char*)poHASHTableNode->oHASHKey.puchKey, poHASHKey->unKeyLength))
		{
			return AMPS_SUCCESS;
		}
	}

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Leaving.\n");

    return AMPS_ERROR_FAILURE;
}

/*****************************************************************
函数名称: HashTable_SearchData
功能描述: 查找指定key值对应的数据
入参:
      void* r_pvAMPSContext 应用上下文
      t_AMPSDList* r_pDList Hash内的双链表
      t_AMPSHashTableKey*  指定的key值


出参:
      
返回值:
      int

*****************************************************************/
void* HashTable_SearchData (void* r_pvAMPSContext, t_AMPSDList* r_pDList, t_AMPSHashTableKey* r_poHASHKey)
{
    //t_AMPSContext* poAMPSContext = (t_AMPSContext*)r_pvAMPSContext;
    t_AMPSSList* poSListNode = NULL;

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Entering.\n");

    poSListNode = DList_Search(r_pDList, HashTable_CompareNodeKey, r_poHASHKey);
    if (NULL != poSListNode)
    {
        if (NULL != poSListNode->pvData)
        {
            return(((t_HASHTableNode*)poSListNode->pvData)->pvData);  //return actual pvData, pvData inside t_HASHTableNode
        }
    }

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Leaving.\n");

    return NULL;
}

/*****************************************************************
函数名称: HashTable_SearchData
功能描述: 获取指定key的位置
入参:
      void* r_pvAMPSContext 应用上下文
      t_AMPSDList* r_pDList Hash内的双链表
      t_AMPSHashTableKey*  指定的key值


出参:
      
返回值:
      int

*****************************************************************/
unsigned int HashTable_Main(void* r_pvAMPSContext, void* r_pvHASHTable, t_AMPSHashTableKey* r_poHASHKey)
{
    t_AMPSContext* poAMPSContext = (t_AMPSContext*)r_pvAMPSContext;
    t_HASHTable* poHashTable = (t_HASHTable*)r_pvHASHTable;

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Entering.\n");

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_DEBUG, "Hash Key Length = %d\n", r_poHASHKey->unKeyLength);
    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_DEBUG, "Hash Key = %s\n", r_poHASHKey->puchKey);

    if (NULL != poHashTable->pfAMPS_HashTableHashCallback)
    {
        /*使用hash函数得到一个位置，这个函数在hash表初始化时由用户定义*/
        return(poHashTable->pfAMPS_HashTableHashCallback (poAMPSContext, poHashTable, r_poHASHKey));
    }

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Leaving.\n");

    return AMPS_ERROR_FAILURE;
}

/*****************************************************************
 下面为几个Hash散列函数举例

*****************************************************************/

//A simple Hash Function for String keys
unsigned int HashTable_StringSum (void* r_pvAMPSContext, void* r_pvHASHTable, t_AMPSHashTableKey* r_poHASHKey)
{
    //t_AMPSContext* poAMPSContext = (t_AMPSContext*)r_pvAMPSContext;
    t_HASHTable* poHashTable = (t_HASHTable*)r_pvHASHTable;
    //Sum all the characters that make up the KEY
    unsigned int nHashTableIndex = 0;
    unsigned int unCounter = 0;
    int nSum = 0;

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Entering.\n");

    for (unCounter = 0; unCounter < r_poHASHKey->unKeyLength; unCounter++)
    {
        nSum += r_poHASHKey->puchKey[unCounter];
    }
    //return the sum calculated above mod r_poHASHTable->nHashTableSize
    //ensures that the returned index lies between zero and r_poHASHTable->nHashTableSize

    nHashTableIndex = (nSum % poHashTable->nHashTableSize);

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_DEBUG, "Hash Table Index = %d\n", nHashTableIndex);

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Leaving.\n");

    return nHashTableIndex;
}

//Universal Hash Function for String Keys
unsigned int HashTable_Universal (void* r_pvAMPSContext, void* r_pvHASHTable, t_AMPSHashTableKey* r_poHASHKey)
{
    //t_AMPSContext* poAMPSContext = (t_AMPSContext*)r_pvAMPSContext;
    t_HASHTable* poHashTable = (t_HASHTable*)r_pvHASHTable;
    unsigned int nHashTableIndex = 0;
    int a = 31415;
    int b = 27183;

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Entering.\n");

    for (nHashTableIndex = 0; nHashTableIndex < r_poHASHKey->unKeyLength; nHashTableIndex++, a = a*b % (poHashTable->nHashTableSize - 1))
    {
        nHashTableIndex = (a*nHashTableIndex + r_poHASHKey->puchKey[nHashTableIndex]) % poHashTable->nHashTableSize;
    }

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_DEBUG, "Hash Table Index = %d\n", nHashTableIndex);

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Leaving.\n");

    return nHashTableIndex;
}

#if !defined (HASH_Get16bits)
    #define HASH_Get16bits(cchKey) ((((unsigned int)(((const unsigned char *)(cchKey))[1])) << 8)\
                       +(unsigned int)(((const unsigned char *)(cchKey))[0]) )
#endif


unsigned int HashTable_HashFunc1(void* r_pvAMPSContext, void* r_pvHASHTable, t_AMPSHashTableKey* r_poHASHKey)
{
    t_HASHTable* poHashTable = r_pvHASHTable;
    unsigned int nHashTableIndex = r_poHASHKey->unKeyLength;
	unsigned int unKeyLength = r_poHASHKey->unKeyLength;
	const char* cchKey = (const char*)r_poHASHKey->puchKey;
	unsigned int unTemp = 0;
    int nReminder = 0;

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Entering.\n");

    nReminder = unKeyLength & 3;
    unKeyLength >>= 2;

    for ( ;unKeyLength > 0; unKeyLength--)
    {
        nHashTableIndex  += HASH_Get16bits (cchKey);
        unTemp = (HASH_Get16bits (cchKey+2) << 11) ^ nHashTableIndex;
        nHashTableIndex   = (nHashTableIndex << 16) ^ unTemp;
        cchKey  += 2*sizeof(unsigned short);
        nHashTableIndex  += nHashTableIndex >> 11;
    }

    switch (nReminder)
    {
        case 3: 
			nHashTableIndex += HASH_Get16bits (cchKey);
            nHashTableIndex ^= nHashTableIndex << 16;
            nHashTableIndex ^= cchKey[sizeof (unsigned short)] << 18;
            nHashTableIndex += nHashTableIndex >> 11;
            break;
        case 2: 
			nHashTableIndex += HASH_Get16bits (cchKey);
            nHashTableIndex ^= nHashTableIndex << 11;
            nHashTableIndex += nHashTableIndex >> 17;
            break;
        case 1: 
			nHashTableIndex += *cchKey;
            nHashTableIndex ^= nHashTableIndex << 10;
            nHashTableIndex += nHashTableIndex >> 1;
    }

    nHashTableIndex ^= nHashTableIndex << 3;
    nHashTableIndex += nHashTableIndex >> 5;
    nHashTableIndex ^= nHashTableIndex << 4;
    nHashTableIndex += nHashTableIndex >> 17;
    nHashTableIndex ^= nHashTableIndex << 25;
    nHashTableIndex += nHashTableIndex >> 6;

	nHashTableIndex = (nHashTableIndex % poHashTable->nHashTableSize);

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_DEBUG, "Hash Table Index = %d\n", nHashTableIndex);

    //TRACE( HASH_TRACE_ID(r_pvAMPSContext), AMPS_TRACE_LEVEL_INFO, "Leaving.\n");
    return nHashTableIndex;
}


socrates
关注
专栏目录
初试 Coding.net 在线IDE——WebIDE
kervinwu的专栏
07-20 2万+
初始Coding.net的WebIDE，体验了在线IDE工具，基于Docker，拥有全功能的Linux Shell 环境
C:\Users\Administrator\Desktop\诺蒂菲尔设备资料AMPS-24.PDF
09-10
诺蒂菲尔设备资料AMPS-24、诺蒂菲尔设备资料AMPS-24、
AMPS:内存管理模块源码解读（一）
Socrates的专栏
01-27 3241
在AMPS中，使用内存池来管理内存，具体机制见之前的文章《AMPS:内存管理（二）》，在代码中，使用了两种实现方式，第一种是数组+单链表。今天先看看这个方式下的内存池实现。 AMPS_MemoryMgt.h #ifndef __HEADER_AMPS_MEMORY_MGMT_H__ #define __HEADER_AMPS_MEMORY_MGMT_H__ #include "AMPS_
常见通信RF指标的内在和意义
热门推荐
鹰飞天下
06-26 2万+
进入手机通信行业以来，时常接触到不同的RF指标，对于不同的制式有不同的要求，在论坛上找到一个总结比较好，学习一下。（From 52RD）
AMPS:内存管理（二）
Socrates的专栏
01-15 1746
对于底层的内存管理，AMPS提供了另外一种优化机制，一旦使用底层的内存分配函数（如C的malloc）为内存对象分配好一个大的buffer后，当这个内存对象销毁时，AMPS将这个本来要ree掉buffer存储在一个内部按内存块大小化分的free链表中，这样，当有新的内存对象需要分配时，AMPS先检查这个链表中是否有满足条件（即是否满足所申请的大小）的内存对象，如果有，从此链表中获取，从而避免了调用m
【推荐】ON SEMI 运算放大器(Op Amps) 技术资料合集.zip
09-17
推荐，ON SEMI 运算放大器(Op Amps) 技术资料合集，共107份。 FAN3852-D 麦克风预放大器，带数字输出 FAN4174 运算放大器，轨对轨 IO，3.7Mhz，CMOS 运算放大器 FAN4274-D Single and Dual, Rail-to-Rail IO, CMOS ...
GMapsNearbyPlacesAPI：Google amps附近的地方搜索-> * lat * lon * rad
02-18
GMapsNearbyPlacesAPI 一个g.maps项​​目，根据输入的输入内容搜索附近的地点* lat * lon * rad 这是您可以使用Google Maps制作restApi的项目 用户应该输入输入值lat，long，rad，这是地球上的一个点 ...
AMPS-1D太阳电池模拟软件
02-29
### AMPS-1D太阳电池模拟软件知识点解析 #### 一、AMPS-1D概述 **AMPS-1D**（Analytical Modeling Program with Simulations - 1 Dimensional）是一款由美国宾夕法尼亚州立大学电子材料工艺研究实验室提供的专业一...
AMPS:AES模块源码解读
Socrates的专栏
01-23 5693
AES(Advanced Encryption Standard，高级加密标准)是一个对称密钥加密算法，密钥长度则可以是128，192或256比特。  算法思路(详细信息请见维基百科)：   AES加密过程是在一个4×4的字节矩阵上运作，这个矩阵又称为“体（state）”，其初值就是一个明文区块（矩阵中一个元素大小就是明文区块中的一个Byte）。（Rijndael加密法因支持更大的区块
AMPS:MySQL数据库操作模块源码解读
Socrates的专栏
01-25 3340
本节看看在AMPS中对MySQL数据库的访问操作，它使用MySQL提供的C API接口进行访问，具体各API的使用可参考http://dev.mysql.com/doc/refman/5.6/en/c-api-function-overview.html。  下面看看AMPS中的实现：   AMPS_MySQL.h #ifndef __HEADER_AMPS_MYSQL_ENGINE_H #
AMPS:Oracle数据库操作模块源码解读
Socrates的专栏
01-25 3320
本节看看AMPS中对Oracle数据库进行操作的方法，使用的是Oracle的C访问接口OCI，关于OCI各函数的中文说明可参考这篇文章http://www.cnblogs.com/joeblackzqq/archive/2011/04/24/2026461.html  下面看看AMPS中Oracle操作各函数实现:  AMPS_Oracle.h #ifndef __HEADER_AMPS_D
AMPS:字符串操作源码解读
Socrates的专栏
01-21 3142
字符串处理在软件中非常普遍，AMPS使用C语言编写，所有没有像 标准C++提供的string一样的类型，所以对字符串的处理就是对char *这样的指针处理，为了处理方便，AMPS定义了自己的String类型，如下： typedef struct _AMPSString t_AMPSString; struct _AMPSString { unsigned char* puchData;
AMPS:定时器模块源码解读
Socrates的专栏
01-27 3114
Timer模块的实现比较复杂，需要结合前面的文章《AMPS:定时器管理》才能有所理解，下面看看AMPS中的定时器实现，有些细节方面我也没有想清楚。  AMPS_Timer.h #ifndef __HEADER_AMPS_TIMER_H__ #define __HEADER_AMPS_TIMER_H__ #ifdef __cplusplus extern "C" { #endif #
AMPS:数据库访问模块源码解读
Socrates的专栏
01-25 3108
AMPS做为一个中间件，也提供了访问数据库的接口，目前支持MySQL和Oracle（对我所喜爱PostgreSQL却默认不支持，看来我的爱好属于非主流哈~），下面要看的是DBEngine库，它只做一件事情，就是封装了不同数据库操作的差异，提供一个数据库统一访问接口。下节再看针对不同数据库的具体操作。 AMPS_DBEngine.h #ifndef __HEADER_AMPS_DB_ENGI
AMPS:MD5模块源码解读
Socrates的专栏
01-23 3099
MD5是用于确保信息传输完整一致性的一个哈希算法。  其算法思想如下（摘自维基百科）：     MD5是输入不定长度信息，输出固定长度128-bits的算法。经过程序流程，生成四个32位数据，最后联合起来成为一个128-bits散列。基本方式为，求余、取余、调整长度、与链接变量进行循环运算。得出结果。  是 XOR, AND, OR , NOT 的符号。
AMPS:内存管理模块源码解读（二）
Socrates的专栏
01-27 3072
上节看了AMPS中通过数组+单链表实现的内存池，本节看看另一个实现方式。此方法思路如下：其内存池结构为一个存放已分配内存信息的双链表，一个表示内存池大小的变量，一个指向当前内存链表结点的指针链表，如下： /*内存池结构*/ struct _newMMContext { t_AMPSDList* memBuffList; /*结点链表*/ int nSizeOfBuff;
第三版Op Amps设计指南：实用设计工具和解决方案
Op Amps for Everyone (第三版) - Operational Amplifier 设计指南 Op Amps for Everyone (第三版) 是一本关于运算放大器（Operational Amplifier，简称 Op Amp）设计的指南，由 Ron Mancini 和 Bruce Carter 编辑...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值