le_hashmap.h

Go to the documentation of this file.

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------

#ifndef LEGATO_HASHMAP_INCLUDE_GUARD
#define LEGATO_HASHMAP_INCLUDE_GUARD

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef struct le_hashmap* le_hashmap_Ref_t;

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef struct le_hashmap_It* le_hashmap_It_Ref_t;

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef size_t (*le_hashmap_HashFunc_t)
(
    const void* keyToHashPtr
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef bool (*le_hashmap_EqualsFunc_t)
(
    const void* firstKeyPtr,
    const void* secondKeyPtr
);


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
typedef bool (*le_hashmap_ForEachHandler_t)
(
    const void* keyPtr,
    const void* valuePtr,
    void* contextPtr
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
le_hashmap_Ref_t le_hashmap_Create
(
    const char*                nameStr,          
    size_t                     capacity,         
    le_hashmap_HashFunc_t      hashFunc,         
    le_hashmap_EqualsFunc_t    equalsFunc        
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------

void* le_hashmap_Put
(
    le_hashmap_Ref_t mapRef,   
    const void* keyPtr,        
    const void* valuePtr       
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------

void* le_hashmap_Get
(
    le_hashmap_Ref_t mapRef,   
    const void* keyPtr         
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
void* le_hashmap_GetStoredKey
(
    le_hashmap_Ref_t mapRef,   
    const void* keyPtr         
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------

void* le_hashmap_Remove
(
   le_hashmap_Ref_t mapRef,       
   const void* keyPtr             
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------

bool le_hashmap_isEmpty
(
    le_hashmap_Ref_t mapRef    
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------

size_t le_hashmap_Size
(
    le_hashmap_Ref_t mapRef    
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------

bool le_hashmap_ContainsKey
(
    le_hashmap_Ref_t mapRef,  
    const void* keyPtr        
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------

void le_hashmap_RemoveAll
(
    le_hashmap_Ref_t mapRef    
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
void le_hashmap_ForEach
(
    le_hashmap_Ref_t mapRef,                 
    le_hashmap_ForEachHandler_t forEachFn,   
    void* contextPtr                         
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
le_hashmap_It_Ref_t le_hashmap_GetIterator
(
    le_hashmap_Ref_t mapRef                 
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
le_result_t le_hashmap_NextNode
(
    le_hashmap_It_Ref_t iteratorRef        
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
le_result_t le_hashmap_PrevNode
(
    le_hashmap_It_Ref_t iteratorRef        
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
void const * le_hashmap_GetKey
(
    le_hashmap_It_Ref_t iteratorRef        
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
void const * le_hashmap_GetValue
(
    le_hashmap_It_Ref_t iteratorRef        
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
le_result_t le_hashmap_GetFirstNode
(
    le_hashmap_Ref_t mapRef,   
    void **firstKeyPtr,        
    void **firstValuePtr       
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
le_result_t le_hashmap_GetNodeAfter
(
    le_hashmap_Ref_t mapRef,   
    const void* keyPtr,        
    void **nextKeyPtr,         
    void **nextValuePtr        
);


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------

size_t le_hashmap_CountCollisions
(
    le_hashmap_Ref_t mapRef     
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------

size_t le_hashmap_HashString
(
    const void* stringToHashPtr    
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------

bool le_hashmap_EqualsString
(
    const void* firstStringPtr,    
    const void* secondStringPtr    
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------

size_t le_hashmap_HashUInt32
(
    const void* intToHashPtr    
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------

bool le_hashmap_EqualsUInt32
(
    const void* firstIntPtr,    
    const void* secondIntPtr    
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------

size_t le_hashmap_HashVoidPointer
(
    const void* voidToHashPtr    
);

//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------

bool le_hashmap_EqualsVoidPointer
(
    const void* firstVoidPtr,    
    const void* secondVoidPtr    
);



//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
void le_hashmap_MakeTraceable
(
    le_hashmap_Ref_t mapRef     
);


//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
void le_hashmap_EnableTrace
(
    le_hashmap_Ref_t mapRef     
);


#endif /* LEGATO_HASHMAP_INCLUDE_GUARD */