ks_array.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_array.h"
#include "ks_string.h"

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

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

inline int 
ks_array_length(ks_array_t *a)
{
        return a->length;
}

static void
ks_array_bappend(ks_string_t *r, ks_base_t *b)
{
        ks_array_t      *a = KS_CAST(ks_array, b);
        int                      i;

        ks_string_append(r, "l", 1);
        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_array = {
        "ks_array",                    
        (ks_destroy_t)ks_array_free,   
        (ks_bappend_t)ks_array_bappend 
};

ks_type_t *
ks_array_type()
{
        return &ks_type_array;
}

ks_array_t *
ks_array_new(void)
{
        ks_array_t      *a = (ks_array_t *)ks_malloc(sizeof(ks_array_t));
        ks_array_init(a);
        return a;
}

void
ks_array_init(ks_array_t *a)
{
        a->base.type = &ks_type_array;
        a->size = 20;
        a->length = 0;
        a->data = (ks_base_t **)ks_malloc(a->size * sizeof(ks_base_t *));
        memset(a->data, 0, a->size * sizeof(ks_base_t *));
}

void
ks_array_free(ks_array_t *a)
{
        ks_array_fini(a);
        ks_free(a);
}

void
ks_array_fini(ks_array_t *a)
{
        ks_base_t       *b;
    int                  i;
        for (i = 0; i < a->length; i++) {
                b = ks_array_get(a, i);
                if (b != NULL)
                        ks_destroy(b);
        }
        ks_free(a->data);
}

static void
ks_array_check_idx(ks_array_t *a, int idx)
{
        if (idx >= a->length)
                ks_error("Warning: index %d off end of array length %d",
                        idx, a->length);
}

void
ks_array_extend(ks_array_t *a, int size)
{
        if (size > a->size) {
                a->data = (ks_base_t **)ks_realloc(a->data,
                                                size * sizeof(ks_base_t *));
                a->size = size;
        }
}

void
ks_array_set(ks_array_t *a, int idx, ks_base_t *ptr)
{
        ks_array_check_idx(a, idx);
        ks_destroy(a->data[idx]);
        a->data[idx] = ptr;
}

ks_base_t *
ks_array_get(ks_array_t *a, int idx)
{
        ks_array_check_idx(a, idx);
        return a->data[idx];
}

void
ks_array_add(ks_array_t *a, ks_base_t *ptr)
{
        if (a->length == a->size)
                ks_array_extend(a, 2 * a->length);
        a->data[a->length] = ptr;
        a->length++;
}

void
ks_array_remove(ks_array_t *a, int idx)
{
        ks_array_check_idx(a, idx);
        if (idx < a->length) {
                memmove(
                                &(a->data[idx]),
                                &(a->data[idx + 1]),
                                (a->length - idx - 1) * sizeof(ks_base_t *));
                a->length--;
        }
}

void
ks_array_sort(ks_array_t *a, ks_array_compar func)
{
        qsort(a->data, ks_array_length(a), sizeof(ks_base_t *),
                                        (int(*)(const void *, const void *))func);
}

---