ssp_hash.c

abstract rtos

#include "syscfg.h"

#ifdef __cplusplus
#if __cplusplus
extern "C"{
#endif 
#endif 



#include "aos.h"









#define HASH_MALLOC(ulSize)  aos_smem_alloc( MPE_SYS,SID_HASH,ulSize)
#define HASH_FREE(pData)          AOS_ASSERT(0);

VOID hash_free_allbucket (HASH_TABLE_S *pHashTab, VOID  (*pMemFreeFunc)(VOID *));













 


















HASH_TABLE_S *hash_create_table (U32 ulHashSize, U32 (*pInsertFunc)())
{
 HASH_TABLE_S *pHashTab;
 U32           ulHashIndex,ulHashMemSize;

 ulHashMemSize = sizeof(HASH_TABLE_S)+(ulHashSize-1)*sizeof(HASH_BUCKET_S);
 pHashTab = (HASH_TABLE_S *)HASH_MALLOC(ulHashMemSize);
 if(pHashTab != (HASH_TABLE_S *)NULL){
    pHashTab->ulHashSize      = ulHashSize;
    pHashTab->pInsertFunc      = pInsertFunc;

    for(ulHashIndex = 0; ulHashIndex < ulHashSize; ulHashIndex++){
        HASH_BUCKET_INIT(&pHashTab->HashList[ulHashIndex]);
    }
 }
 return(pHashTab);
}


HASH_NODE_S *hash_find_node(HASH_TABLE_S *pHashTab, U32 ulIndex, 
	VOID *pKey, S32 (*fnValCmp)(VOID *, HASH_NODE_S *))
{
	HASH_NODE_S *pNode;
	
	HASH_Scan_Bucket(pHashTab, ulIndex, pNode, HASH_NODE_S *)
	{
		if (!fnValCmp(pKey, pNode))
			return pNode;
	}

	return NULL;
}















 




VOID hash_add_node (HASH_TABLE_S *pHashTab, HASH_NODE_S *pNode, U32 ulHashIndex, U8 *pu1InsertFuncParam)
{
 U8 u1Found = FALSE;
 HASH_NODE_S *pTmpNodePtr;
 HASH_NODE_S *pPrevNodePtr = NULL;
 S32   i4InsertPos = MATCH_NOT_FOUND;

 if(pHashTab->pInsertFunc == NULL){
	HASH_ADD_NODE(&pHashTab->HashList[ulHashIndex],pNode);
 }
 else{
    HASH_Scan_Bucket(pHashTab,ulHashIndex,pTmpNodePtr,HASH_NODE_S *){

       i4InsertPos= (S32)(*pHashTab->pInsertFunc)(pTmpNodePtr,pu1InsertFuncParam);
       if ((i4InsertPos == INSERT_NEXTTO) ||
             (i4InsertPos == INSERT_PRIORTO)) {
          u1Found = TRUE;
          break;
       }
       pPrevNodePtr = pTmpNodePtr;
    }

    if(u1Found == FALSE) pTmpNodePtr = HASH_LAST_NODE(&pHashTab->HashList[ulHashIndex]);
    
    
    if (i4InsertPos == INSERT_PRIORTO) {
       if (pPrevNodePtr)
          HASH_INSERT_NODE(&pHashTab->HashList[ulHashIndex], pPrevNodePtr, pNode);
       else  
          HASH_INSERT_NODE(&pHashTab->HashList[ulHashIndex], NULL, pNode);
    } 
    else    
       HASH_INSERT_NODE(&pHashTab->HashList[ulHashIndex], pTmpNodePtr, pNode);
 }
}












VOID hash_delete_node (HASH_TABLE_S *pHashTab, HASH_NODE_S  *pNode, U32 ulHashIndex) 
{
 HASH_DELETE_NODE(&pHashTab->HashList[ulHashIndex],pNode);
}
















VOID hash_free_allbucket (HASH_TABLE_S *pHashTab, VOID  (*pMemFreeFunc)(VOID *))
{
 U32           ulHashIndex;
 
 HASH_Scan_Table(pHashTab,ulHashIndex){
   HASH_Bucket_FreeAll(pHashTab, ulHashIndex, pMemFreeFunc);
 }
}
















VOID hash_delete_table (HASH_TABLE_S *pHashTab, VOID  (*pMemFreeFunc)(VOID *))
{
	hash_free_allbucket(pHashTab, pMemFreeFunc);
	HASH_FREE(pHashTab);
}

VOID hash_walk_bucket (HASH_TABLE_S *pHashTab, U32 ulHashIndex, VOID (*fnVisit)(HASH_NODE_S *))
{
	HASH_NODE_S *pNode;

	HASH_Scan_Bucket(pHashTab, ulHashIndex, pNode, HASH_NODE_S *)
	{
		fnVisit(pNode);
	}
}

VOID hash_walk_table (HASH_TABLE_S *pHashTab, VOID (*fnVisit)(HASH_NODE_S *))
{
	U32 ulHashIndex;
	HASH_NODE_S *pNode;

	HASH_Scan_Table(pHashTab, ulHashIndex)
	{
		HASH_Scan_Bucket(pHashTab, ulHashIndex, pNode, HASH_NODE_S *)
		{
			fnVisit(pNode);
		}
	}
}

#ifdef __cplusplus
#if __cplusplus
}
#endif 
#endif