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 1745
对于底层的内存管理，AMPS提供了另外一种优化机制，一旦使用底层的内存分配函数（如C的malloc）为内存对象分配好一个大的buffer后，当这个内存对象销毁时，AMPS将这个本来要ree掉buffer存储在一个内部按内存块大小化分的free链表中，这样，当有新的内存对象需要分配时，AMPS先检查这个链表中是否有满足条件（即是否满足所申请的大小）的内存对象，如果有，从此链表中获取，从而避免了调用m
AMPS:单向链表源码解读
Socrates的专栏
01-19 2707
像单向链表、双向链表、堆、栈等这些基本的数据结构在大型软件中均有很广泛的使用，所以今天看一下AMPS中单向链表的操作函数库，其定义了单向链表的非常多的操作API，且提供了回调函数接口，从而使链表结构用于不同类型的结点，且可以使用户自定义的函数来实现链表排序、结点操作。所以这部分的代码可以做为常用的工具代码，可以在其他项目中广泛应用。  先看看AMPS提供的单链表操作接口有哪些？如下,由函数名称就
AMPS:双向链表源码解读
Socrates的专栏
01-19 2880
本节在上节单向链表的基础上看看AMPS中对双向链表的实现，与单向链表相同，双向链表在软件中的使用也相对比较广泛，在后面要讲到的Hash表、定时器、内存管理等模块中都会见到以双向链表作为基本数据结构。其实，双向链表在实现上使用了很多单向链表的操作，仅在插入、删除结点时需要多操作几步，所以理解了单向链表，这块就比较好理解了。   同样，AMPS提供了以下API对双向链表进行操作：    AMPS
AMPS:定时器模块源码解读
Socrates的专栏
01-27 3113
Timer模块的实现比较复杂，需要结合前面的文章《AMPS:定时器管理》才能有所理解，下面看看AMPS中的定时器实现，有些细节方面我也没有想清楚。  AMPS_Timer.h #ifndef __HEADER_AMPS_TIMER_H__ #define __HEADER_AMPS_TIMER_H__ #ifdef __cplusplus extern "C" { #endif #
AMPS:日志模块源码解读
Socrates的专栏
01-24 2927
看看AMPS中的日志模块，有两种写日志的方法，一是直接使用封装好的API函数写，另一种是通过应用层注册的日志回调函数，利用事件管理机制来写。   AMPS_Log.h #ifndef __HEADER_AMPS_LOG_H__ #define __HEADER_AMPS_LOG_H__ #include #include "AMPS_SystemAPI.h" #include "AMP
【推荐】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:Cache模块源码解读
Socrates的专栏
01-27 2771
这里讲的Cache并不是通常说的计算机存储系统中的高速缓存，而是软件层面的缓存，它的做用主要是为了提高数据处理的效率。在AMPS中，Cache的结构如下： /*Cache结构*/ struct _AMPSCache { void* pvHASHTable; /*Hash表，用于查找*/ void* pvHeap; /*堆，用于增删改*/ int nCacheSize;
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
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值