kMap.h

Go to the documentation of this file.

#ifndef K_API_MAP_H
#define K_API_MAP_H

#include <kApi/kApiDef.h>

//typedef kObject kMap;   --forward-declared in kApiDef.x.h

typedef kPointer kMapItem; 

#include <kApi/Data/kMap.x.h>

kFx(kStatus) kMap_Construct(kMap* map, kType keyType, kType valueType, kSize initialCapacity, kAlloc allocator);

kFx(kStatus) kMap_Allocate(kMap map, kType keyType, kType valueType, kSize initialCapacity);

kFx(kStatus) kMap_Assign(kMap map, kMap source);

kInlineFx(kStatus) kMap_SetEqualsFx(kMap map, kEqualsFx function)
{
    kObj(kMap, map);   

    obj->equalsFx = function; 

    return kOK; 
}
kInlineFx(kStatus) kMap_SetHashFx(kMap map, kHashFx function)
{
    kObj(kMap, map);   
   
    obj->hashFx = function; 

    kCheck(xkMap_Rehash(map)); 

    return kOK; 
}

kInlineFx(kType) kMap_KeyType(kMap map)
{
    kObj(kMap, map);   

    return obj->keyField.type; 
}

kInlineFx(kType) kMap_ValueType(kMap map)
{
    kObj(kMap, map);   

    return obj->valueField.type; 
}

kInlineFx(kSize) kMap_Count(kMap map)
{
    kObj(kMap, map);   

    return obj->count; 
}

kInlineFx(kSize) kMap_Capacity(kMap map)
{
    kObj(kMap, map);   

    return obj->capacity; 
}

kFx(kStatus) kMap_Find(kMap map, const void* key, void* value);

#define kMap_FindT(kMap_map, KPtr_key, VPtr_value) \
    xkMap_FindT(kMap_map, KPtr_key, VPtr_value, sizeof(*(KPtr_key)), sizeof(*(VPtr_value)))

kInlineFx(kBool) kMap_Has(kMap map, const void* key)
{
    return kSuccess(kMap_Find(map, key, kNULL));
}

#define kMap_HasT(kMap_map, KPtr_key) \
     xkMap_HasT(kMap_map, KPtr_key, sizeof(*(KPtr_key)))

kInlineFx(kStatus) kMap_Add(kMap map, const void* key, const void* value)
{
    return kMap_AddItem(map, key, value, kNULL); 
}

#define kMap_AddT(kMap_map, KPtr_key, VPtr_value) \
    xkMap_AddT(kMap_map, KPtr_key, VPtr_value, sizeof(*(KPtr_key)), sizeof(*(VPtr_value)))

kFx(kStatus) kMap_Replace(kMap map, const void* key, const void* value); 

#define kMap_ReplaceT(kMap_map, KPtr_key, VPtr_value) \
    xkMap_ReplaceT(kMap_map, KPtr_key, VPtr_value, sizeof(*(KPtr_key)), sizeof(*(VPtr_value)))

kFx(kStatus) kMap_Remove(kMap map, const void* key, void* oldKey, void* oldValue); 

#define kMap_RemoveT(kMap_map, KPtr_key, KPtr_oldKey, VPtr_oldValue) \
    xkMap_RemoveT(kMap_map, KPtr_key, KPtr_oldKey, VPtr_oldValue, sizeof(*(KPtr_key)), sizeof(*(KPtr_oldKey)), sizeof(*(VPtr_oldValue)))

kInlineFx(kStatus) kMap_Discard(kMap map, const void* key)
{
    return kMap_Remove(map, key, kNULL, kNULL);
}

#define kMap_DiscardT(kMap_map, KPtr_key) \
    xkMap_DiscardT(kMap_map, KPtr_key, sizeof(*(KPtr_key)))

kFx(kStatus) kMap_Reserve(kMap map, kSize capacity); 

kFx(kStatus) kMap_Clear(kMap map); 

kFx(kStatus) kMap_Purge(kMap map); 

kFx(kMapItem) kMap_First(kMap map); 

kFx(kMapItem) kMap_Next(kMap map, kMapItem item); 

kFx(kStatus) kMap_AddItem(kMap map, const void* key, const void* value, kMapItem* item); 

#define kMap_AddItemT(kMap_map, KPtr_key, VPtr_value, kMapItemPtr_item) \
    xkMap_AddItemT(kMap_map, KPtr_key, VPtr_value, kMapItemPtr_item, sizeof(*(KPtr_key)), sizeof(*(VPtr_value)))

kFx(kStatus) kMap_FindItem(kMap map, const void* key, kMapItem* item); 

#define kMap_FindItemT(kMap_map, KPtr_key, kMapItemPtr_item) \
    xkMap_FindItemT(kMap_map, KPtr_key, kMapItemPtr_item, sizeof(*(KPtr_key)))

kFx(kStatus) kMap_RemoveItem(kMap map, kMapItem item); 

kInlineFx(const void*) kMap_Key(kMap map, kMapItem item)
{   
    kObj(kMap, map);   

    return kPointer_ByteOffset(item, (kSSize)obj->keyField.offset);
}

#define kMap_KeyT(kMap_map, kMapItem_item, K) \
    kCast(K*, xkMap_KeyT(kMap_map, kMapItem_item, sizeof(K)))

#define kMap_KeyAsT(kMap_map, kMapItem_item, K) \
    kPointer_ReadAs(xkMap_KeyAsT(kMap_map, kMapItem_item, sizeof(K)), K)

kInlineFx(void*) kMap_Value(kMap map, kMapItem item)
{   
    kObj(kMap, map);   

    return kPointer_ByteOffset(item, (kSSize)obj->valueField.offset);
}

#define kMap_ValueT(kMap_map, kMapItem_item, V) \
    kCast(V*, xkMap_ValueT(kMap_map, kMapItem_item, sizeof(V)))

kInlineFx(kStatus) kMap_SetValue(kMap map, kMapItem item, const void* value)
{
    kObj(kMap, map);   
    void* valueSlot = kMap_Value(map, item); 

    kValue_Import(obj->valueField.type, valueSlot, value); 

    return kOK; 
} 

#define kMap_SetValueT(kMap_map, kMapItem_item, VPtr_value) \
    xkMap_SetValueT(kMap_map, kMapItem_item, VPtr_value, sizeof(*(VPtr_value)))

#define kMap_SetValueAsT(kMap_map, kMapItem_item, V_value, V) \
    (kPointer_WriteAs(xkMap_ValueAsT(kMap_map, kMapItem_item, sizeof(V)), V_value, V), (void)0) 

#define kMap_ValueAsT(kMap_map, kMapItem_item, V) \
    kPointer_ReadAs(xkMap_ValueAsT(kMap_map, kMapItem_item, sizeof(V)), V) 

#endif