ks_assoc.c

Go to the documentation of this file.

/*
 * libkarmaclient - A C Library to the Karmasphere Reputation Server
 * Copyright (C) 2006 Karmasphere <http://www.karmasphere.com/>
 *  - Shevek <shevek@karmasphere.com>
 *  - Dave Stewart <dave.stewart@karmasphere.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
 */

#include "ks_config.h"
#include "ks_assoc.h"
#include "ks_string.h"

#ifdef HAVE_STRING_H
#include <string.h>
#endif

#ifdef HAVE_STDIO_H
#include <stdio.h>
#endif

static ks_type_t * ks_bucket_type(void);

static void
ks_bucket_free(ks_bucket_t *b)
{
        ks_free(b->key);
        ks_destroy(b->data);
        ks_free(b);
}

static void
ks_bucket_bappend(ks_string_t *r, ks_base_t *b)
{
        ks_bucket_t     *u = KS_CAST(ks_bucket, b);
        char             buf[32];

        snprintf(buf, 31, "%d", u->klen);
        buf[31] = '\0';
        ks_string_append(r, buf, strlen(buf));
        ks_string_append(r, ":", 1);
        ks_string_append(r, u->key, u->klen);
        ks_bappend(r, u->data);
}

static int
ks_bucket_keycompare(const ks_base_t *a, const ks_base_t *b)
{
#if 0
        const ks_bucket_t       *aa = KS_CAST(ks_bucket, a);
        const ks_bucket_t       *bb = KS_CAST(ks_bucket, b);
#else
        const ks_bucket_t       *aa = (ks_bucket_t *)a;
        const ks_bucket_t       *bb = (ks_bucket_t *)b;
#endif
        size_t   len = aa->klen;
        int              cmp;
        if (bb->klen < len)
                len = bb->klen;
        cmp = memcmp(aa->key, bb->key, len);
        if (cmp != 0)
                return cmp;
        return bb->klen - aa->klen;
}

static void
ks_assoc_bappend(ks_string_t *r, ks_base_t *b)
{
        ks_assoc_t      *s = KS_CAST(ks_assoc, b);
        ks_array_t      *a = &(s->array);
        int                      i;
        ks_string_append(r, "d", 1);
        ks_array_sort(a, ks_bucket_keycompare);
        for (i = 0; i < ks_array_length(a); i++)
                ks_bappend(r, ks_array_get(a, i));
        ks_string_append(r, "e", 1);
}

static ks_type_t ks_type_bucket = {
        "ks_bucket",                    
        (ks_destroy_t)ks_bucket_free,   
        (ks_bappend_t)ks_bucket_bappend 
};

static ks_type_t *
ks_bucket_type(void)
{
        return &ks_type_bucket;
}

static ks_type_t ks_type_assoc = {
        "ks_assoc",                    
        (ks_destroy_t)ks_assoc_free,   
        (ks_bappend_t)ks_assoc_bappend 
};

ks_type_t *
ks_assoc_type(void)
{
        return &ks_type_assoc;
}

static ks_bucket_t *
ks_bucket_new(const char *key, size_t len, ks_base_t *data)
{
        ks_bucket_t     *b = (ks_bucket_t *)ks_malloc(sizeof(ks_bucket_t));
        b->base.type = &ks_type_bucket;
        b->key = (char *) ks_malloc(len);
        b->klen = len;
        memcpy(b->key, key, len);
        b->data = data;
        return b;
}

void
ks_assoc_init(ks_assoc_t *s)
{
        s->base.type = &ks_type_assoc;
        ks_array_init(&(s->array));
}

ks_assoc_t *
ks_assoc_new(void)
{
        ks_assoc_t      *s = (ks_assoc_t *)ks_malloc(sizeof(ks_assoc_t));
        ks_assoc_init(s);
        return s;
}

void
ks_assoc_fini(ks_assoc_t *s)
{
        ks_array_fini(&(s->array));
}

void
ks_assoc_free(ks_assoc_t *s)
{
        ks_assoc_fini(s);
        ks_free(s);
}

static ks_bucket_t *
ks_assoc_bucket_find(ks_assoc_t *s, const char *key, size_t klen)
{
        ks_array_t      *a = &(s->array);
        int     i;
        for (i = 0; i < ks_array_length(a); i++) {
                ks_bucket_t     *b = KS_CAST(ks_bucket, ks_array_get(a, i));
                if (klen == b->klen)
                        if (memcmp(key, b->key, b->klen) == 0)
                                return b;
        }
        return NULL;
}

void
ks_assoc_put(ks_assoc_t *s, const char *key, size_t len, ks_base_t *ptr)
{
        ks_bucket_t     *b = ks_assoc_bucket_find(s, key, len);
        if (b == NULL) {
                ks_array_t      *a = &(s->array);
                b = ks_bucket_new(key, len, ptr);
                ks_array_add(a, (ks_base_t *)b);
        }
        else {
                ks_destroy(b->data);
                b->data = ptr;
        }
}

ks_base_t *
ks_assoc_get(ks_assoc_t *s, const char *key, size_t len)
{
        ks_bucket_t     *b = ks_assoc_bucket_find(s, key, len);
        if (b == NULL)
                return NULL;
        return b->data;
}

int
ks_assoc_size(ks_assoc_t *s)
{
        ks_array_t      *a = &(s->array);
        return ks_array_length(a);
}

ks_array_t *
ks_assoc_keys(ks_assoc_t *s)
{
        ks_array_t      *a = &(s->array);
        ks_array_t      *o = ks_array_new();
        int     i;
        for (i = 0; i < ks_array_length(a); i++) {
                ks_bucket_t     *b = KS_CAST(ks_bucket, ks_array_get(a, i));
                ks_string_t     *r = ks_string_new(b->key, b->klen);
                ks_array_add(o, (ks_base_t *)r);
        }
        return o;
}

---