keyvalue.c

Go to the documentation of this file.

 
/***** Feature test switches ************************************************/
/***** System headers *******************************************************/
//@cond
#include "vm_config.h"
#include <stdlib.h>
#include <string.h>
//@endcond
 
/***** Local headers ********************************************************/
#include "mrubyc.h"
 
/***** Constat values *******************************************************/
#if !defined(MRBC_KV_SIZE_INIT)
#define MRBC_KV_SIZE_INIT 2
#endif
#if !defined(MRBC_KV_SIZE_INCREMENT)
#define MRBC_KV_SIZE_INCREMENT 5
#endif
 
/***** Macros ***************************************************************/
/***** Typedefs *************************************************************/
/***** Function prototypes **************************************************/
/***** Local variables ******************************************************/
/***** Global variables *****************************************************/
/***** Signal catching functions ********************************************/
/***** Local functions ******************************************************/
//================================================================
static int binary_search(mrbc_kv_handle *kvh, mrbc_sym sym_id)
{
  int left = 0;
  int right = kvh->n_stored - 1;
  if( right < 0 ) return -1;
 
  while( left < right ) {
    int mid = (left + right) / 2;
    if( kvh->data[mid].sym_id < sym_id ) {
      left = mid + 1;
    } else {
      right = mid;
    }
  }
 
  return left;
}
 
 
/***** Global functions *****************************************************/
 
//================================================================
mrbc_kv_handle * mrbc_kv_new(struct VM *vm, int size)
{
  mrbc_kv_handle *kvh = mrbc_alloc(vm, sizeof(mrbc_kv_handle));
 
  mrbc_kv_init_handle( vm, kvh, size );
 
  return kvh;
}
 
 
//================================================================
int mrbc_kv_init_handle(struct VM *vm, mrbc_kv_handle *kvh, int size)
{
  kvh->data_size = size;
  kvh->n_stored = 0;
 
  if( size == 0 ) {
    // save VM address temporary.
    kvh->vm = vm;
 
  } else {
    // Allocate data buffer.
    kvh->data = mrbc_alloc(vm, sizeof(mrbc_kv) * size);
 
#if defined(MRBC_DEBUG)
    memcpy( kvh->data->obj_mark_, "KV", 2 );
#endif
  }
 
  return 0;
}
 
 
//================================================================
void mrbc_kv_delete(mrbc_kv_handle *kvh)
{
  mrbc_kv_delete_data(kvh);
  mrbc_raw_free(kvh);
}
 
 
//================================================================
void mrbc_kv_delete_data(mrbc_kv_handle *kvh)
{
  if( kvh->data_size == 0 ) return;
 
  mrbc_kv_clear(kvh);
  kvh->data_size = 0;
  mrbc_raw_free(kvh->data);
}
 
 
#if defined(MRBC_ALLOC_VMID)
//================================================================
void mrbc_kv_clear_vm_id(mrbc_kv_handle *kvh)
{
  if( kvh->data_size == 0 ) return;
 
  mrbc_kv *p1 = kvh->data;
  const mrbc_kv *p2 = p1 + kvh->n_stored;
 
  mrbc_set_vm_id( p1, 0 );
 
  while( p1 < p2 ) {
    mrbc_clear_vm_id(&p1->value);
    p1++;
  }
}
#endif
 
 
//================================================================
int mrbc_kv_resize(mrbc_kv_handle *kvh, int size)
{
  if( size <= 0 ) size = 1;
 
  mrbc_kv *data = mrbc_raw_realloc(kvh->data, sizeof(mrbc_kv) * size);
 
  kvh->data = data;
  kvh->data_size = size;
 
  return 0;
}
 
 
//================================================================
int mrbc_kv_set(mrbc_kv_handle *kvh, mrbc_sym sym_id, mrbc_value *set_val)
{
  int idx = binary_search(kvh, sym_id);
  if( idx < 0 ) {
    idx = 0;
    goto INSERT_VALUE;
  }
 
  // replace value ?
  if( kvh->data[idx].sym_id == sym_id ) {
    mrbc_decref( &kvh->data[idx].value );
    kvh->data[idx].value = *set_val;
    return 0;
  }
 
  if( kvh->data[idx].sym_id < sym_id ) {
    idx++;
  }
 
 INSERT_VALUE:
  // need alloc?
  if( kvh->data_size == 0 ) {
    kvh->data = mrbc_alloc(kvh->vm, sizeof(mrbc_kv) * MRBC_KV_SIZE_INIT);
    kvh->data_size = MRBC_KV_SIZE_INIT;
 
#if defined(MRBC_DEBUG)
    memcpy( kvh->data->obj_mark_, "KV", 2 );
#endif
 
  // need resize?
  } else if( kvh->n_stored >= kvh->data_size ) {
    mrbc_kv_resize(kvh, kvh->data_size + MRBC_KV_SIZE_INCREMENT);
  }
 
  // need move data?
  if( idx < kvh->n_stored ) {
    int size = sizeof(mrbc_kv) * (kvh->n_stored - idx);
    memmove( &kvh->data[idx+1], &kvh->data[idx], size );
  }
 
  kvh->data[idx].sym_id = sym_id;
  kvh->data[idx].value = *set_val;
  kvh->n_stored++;
 
  return 0;
}
 
 
 
//================================================================
mrbc_value * mrbc_kv_get(mrbc_kv_handle *kvh, mrbc_sym sym_id)
{
  int idx = binary_search(kvh, sym_id);
  if( idx < 0 ) return NULL;
  if( kvh->data[idx].sym_id != sym_id ) return NULL;
 
  return &kvh->data[idx].value;
}
 
 
#if 0
//================================================================
int mrbc_kv_append(mrbc_kv_handle *kvh, mrbc_sym sym_id, mrbc_value *set_val)
{
  // need alloc?
  if( kvh->data_size == 0 ) {
    kvh->data = mrbc_alloc(kvh->vm, sizeof(mrbc_kv) * MRBC_KV_SIZE_INIT);
    kvh->data_size = MRBC_KV_SIZE_INIT;
 
#if defined(MRBC_DEBUG)
    memcpy( kvh->data->obj_mark_, "KV", 2 );
#endif
 
  // need resize?
  } else if( kvh->n_stored >= kvh->data_size ) {
    mrbc_kv_resize(kvh, kvh->data_size + MRBC_KV_SIZE_INCREMENT);
  }
 
  kvh->data[kvh->n_stored].sym_id = sym_id;
  kvh->data[kvh->n_stored].value = *set_val;
  kvh->n_stored++;
 
  return 0;
}
 
 
 
static int compare_key( const void *kv1, const void *kv2 )
{
  return ((mrbc_kv *)kv1)->sym_id - ((mrbc_kv *)kv2)->sym_id;
}
 
//================================================================
int mrbc_kv_reorder(mrbc_kv_handle *kvh)
{
  if( kvh->data_size == 0 ) return 0;
 
  qsort( kvh->data, kvh->n_stored, sizeof(mrbc_kv), compare_key );
 
  return 0;
}
#endif
 
 
//================================================================
int mrbc_kv_remove(mrbc_kv_handle *kvh, mrbc_sym sym_id)
{
  int idx = binary_search(kvh, sym_id);
  if( idx < 0 ) return 0;
  if( kvh->data[idx].sym_id != sym_id ) return 0;
 
  mrbc_decref( &kvh->data[idx].value );
  kvh->n_stored--;
  memmove( kvh->data + idx, kvh->data + idx + 1,
           sizeof(mrbc_kv) * (kvh->n_stored - idx) );
 
  return 0;
}
 
 
 
//================================================================
void mrbc_kv_clear(mrbc_kv_handle *kvh)
{
  mrbc_kv *p1 = kvh->data;
  const mrbc_kv *p2 = p1 + kvh->n_stored;
  while( p1 < p2 ) {
    mrbc_decref(&p1->value);
    p1++;
  }
 
  kvh->n_stored = 0;
}
 
 
//================================================================
void mrbc_kv_dup(const mrbc_kv_handle *src, mrbc_kv_handle *dst)
{
  mrbc_kv_iterator ite = mrbc_kv_iterator_new( src );
 
  while( mrbc_kv_i_has_next( &ite ) ) {
    mrbc_kv *kv = mrbc_kv_i_next( &ite );
    mrbc_incref( &kv->value );
    mrbc_kv_set( dst, kv->sym_id, &kv->value );
  }
}