ston.c

Go to the documentation of this file.

#include <sys/types.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#include <list.h>
#include <ston.h>

struct ston_item {
        struct list_head head;

        const void *key; /* 오브젝트 아이디 */
        void *obj; /* 생성된 오브젝트 */
        int refcnt; /* 오브젝트 참조 개수 */
};

struct ston {
        struct list_head items;

        struct ston_ops ops; /* 오브젝트 연산자: 생성, 소멸 관리 */
};

struct ston *ston_init(struct ston_ops *ops)
{
        struct ston *ston;

        ston = malloc(sizeof(*ston));
        if (!ston) {
                return NULL;
        }

        memcpy(&ston->ops, ops, sizeof(*ops));
        INIT_LIST_HEAD(&ston->items);

        return ston;
}

int ston_fini(struct ston *ston)
{
        struct list_head *pos;
        struct list_head *n;
        struct ston_item *item;

        list_for_each_safe(pos, n, &ston->items) {
                item = list_entry(pos, struct ston_item, head);
                list_del(pos);

                ston->ops.destroy(item->obj);
                free(item);
        }

        free(ston);
        return 0;
}

static int default_compare(const void *key_a, const void *key_b)
{
        return (uint32_t)key_a != (uint32_t)key_b;
}

static inline struct ston_item *find_item(struct ston *ston, const void *key)
{
        struct ston_item *item;
        struct list_head *pos;
        int (*compare)(const void *key_a, const void *key_b);

        compare = ston->ops.compare ? ston->ops.compare : default_compare;

        list_for_each(pos, &ston->items) {
                item = list_entry(pos, struct ston_item, head);

                if (!compare(item->key, key)) {
                        return item;
                }
        }

        return NULL;
}

static inline struct ston_item *find_item_obj(struct ston *ston, void *obj)
{
        struct ston_item *item;
        struct list_head *pos;

        list_for_each(pos, &ston->items) {
                item = list_entry(pos, struct ston_item, head);

                if (item->obj == obj) {
                        return item;
                }
        }

        return NULL;
}

void *ston_create(struct ston *ston, const void *key)
{
        struct ston_item *item;

        item = find_item(ston, key);
        if (item) {
                return item->obj;
        }

        item = malloc(sizeof(*item));
        if (!item) {
                return NULL;
        }

        item->key = key;
        item->refcnt = 1;
        item->obj = ston->ops.create(key);

        list_add_tail(&item->head, &ston->items);
        return item->obj;
}

int ston_destroy(struct ston *ston, void *obj)
{
        struct ston_item *item;
        int (*destroy)(void *item);

        item = find_item_obj(ston, obj);
        if (!item) {
                return -ENOENT;
        }

        item->refcnt--;
        if (item->refcnt > 0) {
                return 0;
        }

        destroy = ston->ops.destroy;
        list_del(&item->head);
        free(item);

        return destroy(obj);
}

/* End of a file */