/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 libssts/Map.c

  • Committer: Gustav Hartvigsson
  • Date: 2016-01-26 12:26:20 UTC
  • mto: This revision was merged to the branch mainline in revision 111.
  • Revision ID: gustav.hartvigsson@gmail.com-20160126122620-oul2w8c1pgen0dbx
* Fixed SMap, for the time being...

Show diffs side-by-side

added added

removed removed

Lines of Context:
libssts/Map.c
52
52
                                     SLinkedList * bucket,
53
53
                                     spointer key);
54
54
 
 
55
void
 
56
_internal_s_map_free_buckets (SLinkedList * bucket);
 
57
 
55
58
SMapItem *
56
59
s_map_item_new (void * key, void * value) {
57
60
  SMapItem * self = malloc (sizeof (SMapItem));
67
70
                 FreeFunc free_value) {
68
71
  s_dbg_print ("Freeing Item!");
69
72
  if (free_key) {
 
73
    s_dbg_print ("Freeing Key");
70
74
    free_key (self->key);
71
75
  }
72
76
  if (free_value) {
 
77
    s_dbg_print ("Freeing Value");
73
78
    free_value (self->value);
74
79
  }
75
80
  free (self);
76
81
}
77
82
 
78
 
void
79
 
_internal_s_map_free_buckets (SLinkedList * self);
80
83
 
81
84
SMap *
82
85
s_map_new (CompFunc comp_func,
99
102
   * Creating a place to store the items.
100
103
   */
101
104
  self->array = s_dynamic_array_new (S_MAP_DEFAULT_NUMBER_OF_BUCKETS,
102
 
                                     FREEFUNC (s_map_item_free));
 
105
                                     FREEFUNC(_internal_s_map_free_buckets));
103
106
  
104
107
  /* if no func is set we have to use some other metod of
105
108
   */
118
121
  s_map_for_each (self,
119
122
                  FOREACHFUNC(_s_map_internal_free_map_items_for_each),
120
123
                  free_data);
121
 
 
122
 
  s_dynamic_array_free (self->array, FALSE);
 
124
  
 
125
  s_dynamic_array_free (self->array, TRUE);
123
126
  free (self);
124
127
}
125
128
 
165
168
 
166
169
spointer
167
170
s_map_get (SMap * self, spointer key) {
168
 
  spointer ret_val = NULL;
 
171
  return s_map_get_item(self, key)->value;
 
172
}
169
173
 
 
174
SMapItem *
 
175
s_map_get_item (SMap * self, spointer key) {
170
176
  SLinkedList * bucket = _s_map_internal_find_bucket (self, key);
171
177
  if (bucket) {
172
178
    SMapItem * item = _s_map_internal_find_item_in_bucket (self, bucket, key);
173
179
    if (item) {
174
 
      ret_val = item->value;
 
180
      return item;
175
181
    }
176
182
  }
177
 
 
178
 
  return ret_val;
 
183
  return NULL;
179
184
}
180
185
 
181
186
void
257
262
  }
258
263
}
259
264
 
 
265
void
 
266
_internal_s_map_free_buckets (SLinkedList * bucket) {
 
267
  s_linked_list_free (bucket, FALSE);
 
268
}
 
269