/+junk/c_sdl_joypad_ducktape

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/%2Bjunk/c_sdl_joypad_ducktape

« back to all changes in this revision

Viewing changes to src/DynamicArray.c

  • Committer: Gustav Hartvigsson
  • Date: 2014-08-30 21:14:57 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20140830211457-36050zuhlyy8103g
* Fixed the DynamicArray
* Made the docs better (untested)
* Changes a few names.
* and other things.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/DynamicArray.c
12
12
 * Author Gustav Hartvigsson <gustav.hartvigsson _at_ gmail.com> 2014
13
13
 */
14
14
 
15
 
struct _DynamicArray {
16
 
  void ** array;
 
15
struct DynamicArray {
17
16
  size_t max_size;
18
17
  size_t len;
 
18
  FreeFunc free_func;
 
19
  void ** array;
19
20
};
20
21
 
21
 
DynamicArray * dynamic_array_new (size_t len) {
 
22
void * _private_for_each_item_free (DynamicArray * self, void * item,
 
23
                                    void * data);
 
24
 
 
25
DynamicArray * dynamic_array_new (size_t len, FreeFunc free_func) {
22
26
  DynamicArray * self = malloc (sizeof(DynamicArray));
23
27
  
24
28
  self->max_size = len;
25
29
  self->len = 0;
26
30
  
27
 
  self->array = malloc (len);
 
31
  self->free_func = free_func;
 
32
  
 
33
  self->array = malloc (len * sizeof (* self->array));
28
34
  
29
35
  return self;
30
36
}
31
37
 
32
38
void dynamic_array_free (DynamicArray * self) {
 
39
  if (self->free_func != NULL) {
 
40
    dynamic_array_for_each (self, (ForEachFunc) _private_for_each_item_free,
 
41
                            NULL);
 
42
  } else {
 
43
    for (int i = 0; i < self->len; i++) {
 
44
      free (self->array[i]);
 
45
    }
 
46
  }
33
47
  free (self->array);
34
48
  free (self);
35
49
}
47
61
}
48
62
 
49
63
void dynamic_array_add (DynamicArray * self, void * data) {
50
 
  if (self->len >= self->max_size) {
51
 
    self->array = realloc (self->array, self->max_size + ARRAY_PADDING);
 
64
  if (self->len >= self->max_size - 1) {
 
65
    self->array = realloc (self->array,
 
66
                          (sizeof (* self->array) *
 
67
                          (self->max_size + ARRAY_PADDING)));
52
68
    self->max_size = self->max_size + ARRAY_PADDING;
53
69
  }
54
 
  self->array[self->len + 1] = data;
 
70
  self->array[self->len] = data;
55
71
  self->len++;
56
72
}
57
73
 
58
74
void ** dynamic_array_dump_array (DynamicArray * self) {
59
 
  void ** ret_val = malloc (self->len + 1);
60
 
  for (int i = 0; i >= self->len; i++) {
 
75
  void ** ret_val = malloc (sizeof (* self->array) * (self->len + 1));
 
76
  for (int i = 0; i < self->len; i++) {
61
77
    ret_val[i] = self->array[i];
62
78
  }
63
 
  ret_val[self->len + 1] = NULL;
 
79
  ret_val[self->len] = NULL;
64
80
  return ret_val;
65
81
}
66
82
 
67
83
void dynamic_array_for_each (DynamicArray * self, ForEachFunc func,
68
84
                             void * data) {
69
 
  for (int i = 0; i <= self->len; i++) {
 
85
  for (int i = 0; i < self->len; i++) {
70
86
    func (self, self->array[i], data);
71
87
  }
72
88
}
73
89
 
74
90
 
 
91
void * _private_for_each_item_free (DynamicArray * self, void * item,
 
92
                                    void * data) {
 
93
  FreeFunc func = self->free_func;
 
94
  func (item);
 
95
}
 
96