core/index.c

Go to the documentation of this file.

#include <stdlib.h>
#include <memory.h>
#include <string.h>
#include <errno.h>
#include "output.h"
#include "index.h"

static unsigned int next_index_id = 0;

INDEX *index_create(int first_ordinal, 
                    int last_ordinal) 
{
    int size = (unsigned int)(last_ordinal - first_ordinal + 1);
    INDEX *index = malloc(sizeof(INDEX));
    if (index!=NULL)
    {
        if (size<1)
        {
            errno = EINVAL;
            goto Undo;
        }
        index->ordinal = malloc(sizeof(LIST*)*size);
        if (index->ordinal==NULL)
        {
            errno = ENOMEM;
            goto Undo;
        }
        index->id = next_index_id++;
        index->first_ordinal = first_ordinal;
        index->last_ordinal = last_ordinal;
        memset(index->ordinal,0,sizeof(LIST*)*size);
        output_verbose("creating index %d", index->id);
    }
    else
    {
        errno = ENOMEM;
        return NULL;
    }

    /* reversal forces adjustment when first item is received */
    index->first_used=last_ordinal;
    index->last_used=first_ordinal;
    return index;
Undo:
    free(index);
    return NULL;
}

STATUS index_insert(INDEX *index,   
                    void *data,     
                    int ordinal)    
{
    int pos = ordinal - index->first_ordinal;

    if (ordinal<index->first_ordinal) /* grow on bottom end */
    {
        /* (this is very unusual and shouldn't happen the way things are now) */
        output_fatal("ordinal %d is too small (first is %d)",ordinal, index->first_ordinal);
        errno = EINVAL;
        return FAILED;
    }
    else if (ordinal>=index->last_ordinal) /* grow on to end */
    {   
        int oldsize = index->last_ordinal - index->first_ordinal;
        int newsize = oldsize;
        LIST **newblock = NULL;
        while (ordinal >= index->first_ordinal + newsize)
            newsize *= 2;   /* double until it fits */
        newblock = malloc(sizeof(LIST*)*newsize);
        if (newblock==NULL)
        {
            output_fatal("unable to grow index %d: %s",index->id, strerror(errno));
            return FAILED;
        }
        output_verbose("growing index %d to %d ordinals", index->id, newsize);
        memset(newblock,0,sizeof(LIST*)*newsize);
        memcpy(newblock,index->ordinal,sizeof(LIST*)*oldsize);
        free(index->ordinal);
        index->ordinal = newblock;
        index->last_ordinal = index->first_ordinal + newsize;
    
    }
    if (index->ordinal[pos]==NULL) /* new list at ordinal */
    {
        index->ordinal[pos] = list_create();
        if (index->ordinal[pos]==NULL)
            return FAILED;
    }
    if (list_append(index->ordinal[pos],data)==NULL)
        return FAILED;
    if (ordinal<index->first_used) index->first_used=ordinal;
    if (ordinal>index->last_used) index->last_used=ordinal;
    return SUCCESS;
}

void index_shuffle(INDEX *index)    
{
    int i, size = index->last_used - index->first_used;
    for (i=0; i<size; i++)
        list_shuffle(index->ordinal[i]);
    output_verbose("shuffled %d lists in index %d", size, index->id);
}

---

GridLAB-D^TM Version 1.0

An open-source project initiated by the US Department of Energy