hmap.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright (c) 2019-2022 Intel Corporation
 */
 
#ifndef __HMAP_H_
#define __HMAP_H_
 
// IWYU pragma: no_include <bits/stdint-uintn.h>
 
#include <stdbool.h>          // for bool
#include <string.h>           // for NULL
#include <strings.h>          // for strcasecmp
#include <stdint.h>           // for uint32_t, int64_t, uint16_t, uint64_t, uint8_t
#include <stdio.h>            // for FILE
#include <sys/queue.h>        // for TAILQ_ENTRY
#include <pthread.h>          // for pthread_mutex_t
 
#include "cne_common.h"        // for CNDP_API
#include "cne_log.h"           // for CNE_LOG_ERR, CNE_NULL_RET
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define HMAP_MAX_NAME_SIZE     32   
#define HMAP_MAX_KEY_SIZE      256  
#define HMAP_STARTING_CAPACITY 32   
#define HMAP_DEFAULT_CAPACITY  1024 
struct hmap;
 
// clang-format off
typedef enum {
    HMAP_EMPTY_TYPE,
    HMAP_STR_TYPE,
    HMAP_U64_TYPE,
    HMAP_U32_TYPE,
    HMAP_U16_TYPE,
    HMAP_U8_TYPE,
    HMAP_NUM_TYPE,
    HMAP_NUM64_TYPE,
    HMAP_BOOLEAN_TYPE,
    HMAP_POINTER_TYPE,
    HMAP_NUM_TYPES
} hmap_type_t;
// clang-format on
 
typedef union {
    char *str;     
    uint64_t u64;  
    uint32_t u32;  
    uint16_t u16;  
    uint8_t u8;    
    int num;       
    int64_t num64; 
    bool boolean;  
    void *ptr;     
} hmap_val_t;
 
typedef struct hmap_kvp { 
    hmap_type_t type;     
    char *prefix;         
    char *key;            
    hmap_val_t v;         
} hmap_kvp_t;
 
typedef uint32_t (*hash_fn_t)(const char *prefix, const char *key);
typedef int (*cmp_fn_t)(const char *prefix, const char *key, const hmap_kvp_t *kvp);
typedef void (*free_fn_t)(hmap_kvp_t *kvp);
 
typedef struct hmap_funcs {
    hash_fn_t hash_fn; 
    cmp_fn_t cmp_fn;   
    free_fn_t free_fn; 
} hmap_funcs_t;
 
typedef struct hmap {
    TAILQ_ENTRY(hmap) next;        
    char name[HMAP_MAX_NAME_SIZE]; 
    uint32_t capacity;             
    uint32_t max_capacity;         
    uint32_t curr_capacity;        
    pthread_mutex_t mutex;         
    hmap_funcs_t fns;              
    hmap_kvp_t *map;               
} hmap_t;
 
CNDP_API hmap_t *hmap_create(const char *name, uint32_t capacity, hmap_funcs_t *funcs);
 
CNDP_API int hmap_destroy(hmap_t *hmap);
 
CNDP_API int hmap_destroy_by_name(const char *name);
 
CNDP_API hmap_kvp_t *hmap_kvp_lookup(hmap_t *hmap, const char *prefix, const char *key);
 
CNDP_API int hmap_lookup(hmap_t *hmap, const char *prefix, const char *key, hmap_val_t *val);
 
CNDP_API int hmap_add(hmap_t *hmap, hmap_type_t type, const char *prefix, const char *key,
                      hmap_val_t *val);
 
CNDP_API int hmap_kvp_update(hmap_t *hmap, hmap_kvp_t *kvp, hmap_val_t *val);
 
static inline int
hmap_add_string(hmap_t *hmap, const char *prefix, const char *key, const char *val)
{
    hmap_val_t v = {.str = (char *)(uintptr_t)val};
 
    return hmap_add(hmap, HMAP_STR_TYPE, prefix, key, &v);
}
 
static inline int
hmap_add_u64(hmap_t *hmap, const char *prefix, const char *key, uint64_t val)
{
    hmap_val_t v = {.u64 = val};
 
    return hmap_add(hmap, HMAP_U64_TYPE, prefix, key, &v);
}
 
static inline int
hmap_add_u32(hmap_t *hmap, const char *prefix, const char *key, uint32_t val)
{
    hmap_val_t v = {.u32 = val};
 
    return hmap_add(hmap, HMAP_U32_TYPE, prefix, key, &v);
}
 
static inline int
hmap_add_u16(hmap_t *hmap, const char *prefix, const char *key, uint16_t val)
{
    hmap_val_t v = {.u16 = val};
 
    return hmap_add(hmap, HMAP_U16_TYPE, prefix, key, &v);
}
 
static inline int
hmap_add_u8(hmap_t *hmap, const char *prefix, const char *key, uint8_t val)
{
    hmap_val_t v = {.u8 = val};
 
    return hmap_add(hmap, HMAP_U8_TYPE, prefix, key, &v);
}
 
static inline int
hmap_add_num(hmap_t *hmap, const char *prefix, const char *key, int val)
{
    hmap_val_t v = {.num = val};
 
    return hmap_add(hmap, HMAP_NUM_TYPE, prefix, key, &v);
}
 
static inline int
hmap_add_num64(hmap_t *hmap, const char *prefix, const char *key, int64_t val)
{
    hmap_val_t v = {.num64 = val};
 
    return hmap_add(hmap, HMAP_NUM64_TYPE, prefix, key, &v);
}
 
static inline int
hmap_add_bool(hmap_t *hmap, const char *prefix, const char *key, bool val)
{
    hmap_val_t v = {.boolean = val};
 
    return hmap_add(hmap, HMAP_BOOLEAN_TYPE, prefix, key, &v);
}
 
static inline int
hmap_add_pointer(hmap_t *hmap, const char *prefix, const char *key, void *val)
{
    hmap_val_t v = {.ptr = val};
 
    return hmap_add(hmap, HMAP_POINTER_TYPE, prefix, key, &v);
}
 
CNDP_API int hmap_del(hmap_t *hmap, const char *prefix, const char *key);
 
CNDP_API int hmap_iterate(hmap_t *hmap, hmap_kvp_t **_kvp, uint32_t *next);
 
CNDP_API void hmap_dump(FILE *f, hmap_t *hmap, int sort);
 
static inline uint32_t
hmap_capacity(hmap_t *hmap)
{
    return hmap->capacity;
}
 
static inline uint32_t
hmap_count(hmap_t *hmap)
{
    return hmap->curr_capacity;
}
 
CNDP_API hmap_funcs_t *hmap_get_funcs(hmap_t *hmap);
 
CNDP_API int hmap_set_funcs(hmap_t *hmap, hmap_funcs_t *funcs);
 
static inline hmap_kvp_t *
__get_kvp(hmap_t *hmap, const char *prefix, const char *key, hmap_type_t type)
{
    hmap_kvp_t *kvp;
 
    if (!hmap)
        CNE_NULL_RET("get failed - hmap not defined %s(%s)\n", prefix ? prefix : "", key);
 
    kvp = hmap_kvp_lookup(hmap, prefix, key);
    if (!kvp || kvp->type != type)
        CNE_NULL_RET("get failed for %s(%s)\n", prefix ? prefix : "", key);
 
    return kvp;
}
 
static inline int
hmap_get_bool(hmap_t *hmap, const char *prefix, const char *key, bool *val)
{
    hmap_kvp_t *kvp = __get_kvp(hmap, prefix, key, HMAP_BOOLEAN_TYPE);
 
    if (!kvp || kvp->type != HMAP_BOOLEAN_TYPE)
        return -1;
 
    if (val)
        *val = kvp->v.boolean;
 
    return 0;
}
 
static inline int
hmap_get_u64(hmap_t *hmap, const char *prefix, const char *key, uint64_t *val)
{
    hmap_kvp_t *kvp = __get_kvp(hmap, prefix, key, HMAP_U64_TYPE);
 
    if (!kvp || kvp->type != HMAP_U64_TYPE)
        return -1;
 
    if (val)
        *val = kvp->v.u64;
 
    return 0;
}
 
static inline int
hmap_get_u32(hmap_t *hmap, const char *prefix, const char *key, uint32_t *val)
{
    hmap_kvp_t *kvp = __get_kvp(hmap, prefix, key, HMAP_U32_TYPE);
 
    if (!kvp || kvp->type != HMAP_U32_TYPE)
        return -1;
 
    if (val)
        *val = kvp->v.u32;
 
    return 0;
}
 
static inline int
hmap_get_u16(hmap_t *hmap, const char *prefix, const char *key, uint16_t *val)
{
    hmap_kvp_t *kvp = __get_kvp(hmap, prefix, key, HMAP_U16_TYPE);
 
    if (!kvp || kvp->type != HMAP_U16_TYPE)
        return -1;
 
    if (val)
        *val = kvp->v.u16;
 
    return 0;
}
 
static inline int
hmap_get_u8(hmap_t *hmap, const char *prefix, const char *key, uint8_t *val)
{
    hmap_kvp_t *kvp = __get_kvp(hmap, prefix, key, HMAP_U8_TYPE);
 
    if (!kvp || kvp->type != HMAP_U8_TYPE)
        return -1;
 
    if (val)
        *val = kvp->v.u8;
 
    return 0;
}
 
static inline int
hmap_get_num(hmap_t *hmap, const char *prefix, const char *key, int *val)
{
    hmap_kvp_t *kvp = __get_kvp(hmap, prefix, key, HMAP_NUM_TYPE);
 
    if (!kvp || kvp->type != HMAP_NUM_TYPE)
        return -1;
 
    if (val)
        *val = kvp->v.num;
 
    return 0;
}
 
static inline int
hmap_get_num64(hmap_t *hmap, const char *prefix, const char *key, int64_t *val)
{
    hmap_kvp_t *kvp = __get_kvp(hmap, prefix, key, HMAP_NUM64_TYPE);
 
    if (!kvp || kvp->type != HMAP_NUM64_TYPE)
        return -1;
 
    if (val)
        *val = kvp->v.num64;
 
    return 0;
}
 
static inline int
hmap_get_string(hmap_t *hmap, const char *prefix, const char *key, char **val)
{
    hmap_kvp_t *kvp = __get_kvp(hmap, prefix, key, HMAP_STR_TYPE);
 
    if (!kvp || kvp->type != HMAP_STR_TYPE)
        return -1;
 
    if (val)
        *val = kvp->v.str;
 
    return 0;
}
 
static inline int
hmap_get_pointer(hmap_t *hmap, const char *prefix, const char *key, void **val)
{
    hmap_kvp_t *kvp = __get_kvp(hmap, prefix, key, HMAP_POINTER_TYPE);
 
    if (!kvp || kvp->type != HMAP_POINTER_TYPE)
        return -1;
 
    if (val)
        *val = kvp->v.ptr;
 
    return 0;
}
 
void hmap_list_dump(FILE *f, int sort);
 
#ifdef __cplusplus
}
#endif
 
#endif /* __HMAP_H_*/