compile fixes

[lttv.git] / ltt / branches / poly / lttv / attribute.c

#include <lttv/attribute.h>

inline lttv_string_id lttv_string_id_from_string(const char *s) {
  return g_quark_from_string(s);
}


inline void lttv_string_id_release(lttv_string_id i) {}


inline const char *lttv_string_id_to_string(lttv_string_id i) {
  return g_quark_to_string(i);
}


inline lttv_key *lttv_key_new() {
  return g_array_new(FALSE, FALSE, sizeof(lttv_string_id));
}

/* Changed this function to destroy the element also, caused memory leak? */
/* Mathieu Desnoyers */
inline void lttv_key_destroy(lttv_key *k) {
  g_array_free(k, TRUE);
}


#define _lttv_key_index(k,i) g_array_index(k, lttv_string_id, i)


inline void lttv_key_append(lttv_key *k, lttv_string_id i) {
  g_array_append_val(k,i);
}


inline unsigned int lttv_key_component_number(lttv_key *k) {
  return k->len;
}


lttv_key *lttv_key_copy(lttv_key *k) {
  lttv_key *nk;
  int i;

  nk = lttv_key_new();
  for(i = 0 ; i < k->len ; i++) lttv_key_append(nk,lttv_key_index(k,i));
  return nk;
}

/* It is also possible to create a key directly from a pathname,
   key components separated by /, (e.g., "/hooks/options/before"). */

lttv_key *lttv_key_new_pathname(const char *p) {
  char **v, **cursor;
  lttv_key *k;

  v = cursor = g_strsplit(p, "/", -1);
  k = lttv_key_new();

  while(*cursor != NULL) {
    lttv_key_append(k, lttv_string_id_from_string(*cursor));
    cursor++;
  }
  g_strfreev(v);
  return k;
}

static guint lttv_key_hash(gconstpointer key) {
  lttv_key * k = (lttv_key *)key;
  guint h = 0;
  int i;
  for(i = 0 ; i < k->len ; i++) h = h ^ lttv_key_index(k,i);
  return h;
}

static gboolean lttv_key_equal(gconstpointer key1,gconstpointer key2) {
  lttv_key * k1 = (lttv_key *)key1;
  lttv_key * k2 = (lttv_key *)key2;  
  int i;

  if(k1->len != k2->len) return FALSE;
  for(i = 0 ; i < k1->len ; i++) 
    if(lttv_key_index(k1,i) != lttv_key_index(k2,i)) return FALSE;
  return TRUE;
}


static void lttv_key_free(gpointer data)
{
  lttv_key_destroy((lttv_key *)data);
}


static void lttv_attribute_value_free(gpointer data) 
{
  g_free(data);
}


lttv_attributes *lttv_attributes_new() {
  lttv_attributes *a;

  a = g_new(lttv_attributes, 1);
  a->ints = g_hash_table_new_full(lttv_key_hash, lttv_key_equal,
      lttv_key_free, lttv_attribute_value_free);
  a->times = g_hash_table_new_full(lttv_key_hash, lttv_key_equal,
      lttv_key_free, lttv_attribute_value_free);
  a->doubles = g_hash_table_new_full(lttv_key_hash, lttv_key_equal,
      lttv_key_free, lttv_attribute_value_free);
  a->pointers = g_hash_table_new(lttv_key_hash, lttv_key_equal);

  return a;
}


/* Free the hash table containing the stats and all the contained keys/vals */

static void lttv_attribute_key_free(gpointer k, gpointer v, gpointer data) {
  lttv_key_free(k);
}


void lttv_attributes_destroy(lttv_attributes *a) {
  g_hash_table_destroy(a->ints);
  g_hash_table_destroy(a->times);
  g_hash_table_destroy(a->doubles);

  g_hash_table_foreach(a->pointers, lttv_attribute_key_free, NULL);
  g_hash_table_destroy(a->pointers);
  g_free(a);
}

unsigned int lttv_attributes_number(lttv_attributes *a) {
  return g_hash_table_size(a->ints) + g_hash_table_size(a->times) +
      g_hash_table_size(a->doubles) + g_hash_table_size(a->pointers);
}


/* If it is a new entry, insert it in the hash table, and set it to 0 */

int *lttv_attributes_get_integer(lttv_attributes *a, lttv_key *k) 
{
  gpointer found;

  found = g_hash_table_lookup(a->ints, k);
  if(found == NULL) {
    found = g_new(gint, 1);
    *(gint *)found = 0;
    g_hash_table_insert(a->ints, lttv_key_copy(k), found);
  }
  return found;
}


lttv_time *lttv_attributes_get_time(lttv_attributes *a, lttv_key *k) 
{
  gpointer found;
  
  found = g_hash_table_lookup(a->times, k);
  if(found == NULL) {
    found = g_new0(lttv_time, 1);
    /*    *(lttv_time *)found = ZeroTime; */
    g_hash_table_insert(a->times, lttv_key_copy(k), found);
  }
  return found;
}

double *lttv_attributes_get_double(lttv_attributes *a, lttv_key *k) 
{
  gpointer found;

  found = g_hash_table_lookup(a->doubles,k);
  if(found == NULL) {
    found = g_new(double,1);
    *(double *)found = 0;
    g_hash_table_insert(a->doubles, lttv_key_copy(k),found);
  }
  return found;
}

void *lttv_attributes_get_pointer_pathname(lttv_attributes *a, char *pn) 
{
  lttv_key *key;
  void *p;

  key = lttv_key_new_pathname(pn);
  p = lttv_attributes_get_pointer(a, key);
  lttv_key_destroy(key);

  return p;
}

void *lttv_attributes_get_pointer(lttv_attributes *a, lttv_key *k) 
{
  return g_hash_table_lookup(a->pointers,k);
}

void lttv_attributes_set_pointer_pathname(lttv_attributes *a,char *pn,void *p)
{
  lttv_key *key = lttv_key_new_pathname(pn);
  
  lttv_attributes_set_pointer(a, key, p);
  lttv_key_destroy(key);
}

void lttv_attributes_set_pointer(lttv_attributes *a, lttv_key *k, void *p) {
  lttv_key * oldk;
  void *oldv;

  if(g_hash_table_lookup_extended(a->pointers, k, (gpointer)oldk, &oldv)) {
    if(p == NULL) {
      g_hash_table_remove(a->pointers,k);
    } 
    else {
      g_hash_table_insert(a->pointers,oldk,p);
    }
  } 
  else {
    if(p == NULL) return;
    g_hash_table_insert(a->pointers,lttv_key_copy(k),p);
  }
}


/* Sometimes the attributes must be accessed in bulk, sorted in different
   ways. For this purpose they may be converted to arrays and sorted
   multiple times. The keys used in the array belong to the lttv_attributes
   object from which the array was obtained and are freed when it is
   destroyed. Each element in the array is an lttv_attribute, a structure
   containing the key, the value type, and a union containing a value of
   that type. Multiple attributes with equal keys may be possible in some
   implementations if their type differs. */


typedef struct _lttv_attribute_fill_position  {
  unsigned i;
  lttv_attribute_type t;
  lttv_attribute *a;
} lttv_attribute_fill_position;


static void lttv_attribute_fill(void *key, void *value, void *user_data) {
  lttv_attribute_fill_position * p = (lttv_attribute_fill_position *)user_data;
  lttv_attribute *a = p->a + p->i;

  a->key = (lttv_key *)key;
  a->t = p->t;
  switch(p->t) {
    case LTTV_INTEGER:
      a->v.i = *((int *)value);
    case LTTV_TIME:
      a->v.t = *((lttv_time *)value);
    case LTTV_DOUBLE:
      a->v.d = *((double *)value);
    case LTTV_POINTER:
      a->v.p = value;
  }
  p->i++;
}


lttv_attribute *lttv_attributes_array_get(lttv_attributes *a) {
  unsigned size;
  lttv_attribute *v;
  lttv_attribute_fill_position p;

  size = lttv_attributes_number(a);
  v = g_new(lttv_attribute,size);

  p.a = v;
  p.i = 0;
  p.t = LTTV_INTEGER;
  g_hash_table_foreach(a->ints, lttv_attribute_fill, &p);
  p.t = LTTV_TIME;
  g_hash_table_foreach(a->times, lttv_attribute_fill, &p);
  p.t = LTTV_DOUBLE;
  g_hash_table_foreach(a->doubles, lttv_attribute_fill, &p);
  p.t = LTTV_POINTER;
  g_hash_table_foreach(a->pointers, lttv_attribute_fill, &p);
  return v;
}


lttv_attribute *lttv_attribute_array_destroy(lttv_attribute *a) {
  g_free(a);
}


void lttv_attribute_array_sort(lttv_attribute *a,
    unsigned size, lttv_key_compare f,
    void *compare_data)
{
  
  g_qsort_with_data(a, size, sizeof(lttv_attribute), f, 
      compare_data);
}


int lttv_key_compare_priority(lttv_key *a, lttv_key *b, void *compare_data)
{
  int i, res;
  int *priority = (int *)compare_data;

  g_assert(a->len == b->len);

  for(i = 0 ; i < a->len ; i++) 
  {
    res = strcmp(lttv_string_id_to_string(lttv_key_index(a,priority[i])),
        lttv_string_id_to_string(lttv_key_index(a,priority[i])));
    if(res != 0) return res;
  }
  return 0;
}

typedef struct _select_data {
  lttv_attributes *a;
  lttv_key *k;
  void *user_data;
  lttv_key_select select;
} select_data;

static void select_integer(void *key, void *value, void *user_data);
static void select_double(void *key, void *value, void *user_data);
static void select_time(void *key, void *value, void *user_data);
static void select_pointer(void *key, void *value, void *user_data);

lttv_attributes *lttv_attributes_select(lttv_attributes *a, lttv_key_select f, 
    void *user_data)
{
  select_data *d;

  d = g_new(select_data, 1);
  d->a = lttv_attributes_new();
  d->k = lttv_key_new();
  d->user_data = user_data;
  d->select = f;

  g_hash_table_foreach(a->ints,select_integer, d);
  g_hash_table_foreach(a->doubles,select_double, d);
  g_hash_table_foreach(a->times,select_time, d);
  g_hash_table_foreach(a->pointers,select_pointer, d);
}

int lttv_key_select_spec(lttv_key *in, lttv_key *out, void *user_data)
{
  lttv_key_select_spec_data *d = (lttv_key_select_spec_data *)user_data;
  int i;

  /* not defined yet */
  /* lttv_key_set_size(out, 0); */

  for(i = 0 ; i < d->length ; i++) {
    switch(d->spec[i]) {
    case LTTV_KEEP:
      break;

    case LTTV_KEEP_EQUAL:
      break;

    case LTTV_KEEP_SMALLER:
      break;

    case LTTV_KEEP_GREATER:
      break;

    case LTTV_IGNORE:
      break;

    }
  }

  return 1;
}

static void select_integer(void *key, void *value, void *user_data)
{
  lttv_key *k = (lttv_key *)key;
  int *pi = (int *)value;
  select_data *d = (select_data *)user_data;

  if(d->select(k,d->k,d->user_data)) {
    *(lttv_attributes_get_integer(d->a,d->k)) += *pi;
  }
}

static void select_double(void *key, void *value, void *user_data)
{
  lttv_key *k = (lttv_key *)key;
  double *pf = (double *)value;
  select_data *d = (select_data *)user_data;

  if(d->select(k,d->k,d->user_data)) {
    *(lttv_attributes_get_double(d->a,d->k)) += *pf;
  }
}

static void select_time(void *key, void *value, void *user_data)
{
  lttv_key *k = (lttv_key *)key;
  lttv_time *ptSum, *pt = (lttv_time *)value;
  select_data *d = (select_data *)user_data;

  if(d->select(k,d->k,d->user_data)) {
    ptSum = lttv_attributes_get_time(d->a,d->k);
    ptSum->tv_sec += pt->tv_sec;
    ptSum->tv_nsec += pt->tv_nsec;
  }
}

static void select_pointer(void *key, void *value, void *user_data)
{
  lttv_key *k = (lttv_key *)key;
  select_data *d = (select_data *)user_data;

  if(d->select(k,d->k,d->user_data)) {
    lttv_attributes_set_pointer(d->a,d->k,value);
  }
}