/simpletypesystem/trunk

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/simpletypesystem/trunk

« back to all changes in this revision

Viewing changes to src/Map.c

  • Committer: Gustav Hartvigsson
  • Date: 2013-09-09 16:55:42 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20130909165542-24h1f5kylq4qh5r2
* Think I am 70% done with SMap now...
  still needs a lot of testing...

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/Map.c
14
14
  SMapItem * self = malloc (sizeof (SMapItem));
15
15
  self->key = key;
16
16
  self->value = value;
 
17
  return self;
17
18
}
18
19
 
19
 
void s_map_item_free (SMapItem * self) {
20
 
  /* FIXME TODO:
21
 
   * Need to figure a method to determin if objects (keys and values) are
22
 
   * BaseObjectInstance children or not and use the appropriate method for
23
 
   * freeing.
24
 
   */
 
20
void s_map_item_free (SMapItem * self, MethodFunc free_key,
 
21
                                       MethodFunc free_value) {
 
22
  free_key (self->key);
 
23
  free_value (self->value);
25
24
  free (self);
26
25
}
27
26
 
28
 
SMap * s_map_new ( CompFunc comp_func ) {
 
27
SMap * s_map_new ( CompFunc comp_func, MethodFunc free_key,
 
28
                                       MethodFunc free_value) {
29
29
  SMap * self = malloc (sizeof (SMap));
30
30
  SMapClass * klass = malloc (sizeof (SMapClass));
31
31
  
39
39
  
40
40
  klass->is_equal = comp_func;
41
41
  
 
42
  /* free_* functions need to be checked if they are null and set the pointer
 
43
   * to free or s_base_object_free ()... Have to decite which...
 
44
   */
 
45
  klass->free_key = free_key;
 
46
  klass->free_value = free_value;
 
47
 
42
48
  return self;
43
49
}
44
50
 
45
51
void s_map_free (SMap * self) {
46
 
  //TODO
 
52
  s_base_object_free (self);
47
53
}
48
54
 
49
55
 
50
56
void s_map_add (SMap * self ,void * key, void * value) {
51
57
  SMapItem ** items = self->priv->items;
52
58
  SMapItem * item = s_map_item_new (key, value);
 
59
  size_t * len = self->priv->len;
53
60
  if (self->priv->len == 0) {
54
 
    
55
61
    items = realloc (items, sizeof(SMapItem));
56
62
    items[0] = item;
57
63
    self->priv->len++;
58
64
  } else {
59
 
    //TODO
 
65
    items = reallec (items, sizeof(SMapItem) * (self->priv->len + 1));
 
66
    items[len-1] = item;
 
67
    self->priv->len++;
60
68
  }
61
69
}
62
70
 
63
71
void * s_map_get (SMap * self, void * key) {
64
 
  
 
72
  SMapItem ** items = self->priv->items;
 
73
  size_t * len = self->priv->len;
 
74
  SMapClass * klass = (SMapClass *) s_base_object_get_class ((SBaseObjectInstance *) self);
 
75
  CompFunc comp_func = klass->comp_func;
 
76
  for (int i == 0; i < self->priv->len; i++) {
 
77
    bool is_item = comp_func (key, items[i]);
 
78
    if (is_item) {
 
79
      return items[i];
 
80
    }
 
81
  }
 
82
  return NULL;
65
83
}
66
84
 
67
85
void method_map_deinit (SMap * self) {