/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/DynamicArray.c

  • Committer: Gustav Hartvigsson
  • Date: 2014-11-24 13:59:19 UTC
  • mto: This revision was merged to the branch mainline in revision 20.
  • Revision ID: gustav.hartvigsson@gmail.com-20141124135919-3x0u978u98uzjmet
* Copied over LinkedList and DynamicArray from c_sdl_js

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/DynamicArray.c
 
1
/* c-basic-offset: 2; tab-width: 2; indent-tabs-mode: nil
 
2
 * vi: set shiftwidth=2 tabstop=2 expandtab:
 
3
 * :indentSize=2:tabSize=2:noTabs=true:
 
4
 */
 
5
 
 
6
#include "DynamicArray.h"
 
7
 
 
8
/*
 
9
 * This file, as the rest of the project is under MIT license.
 
10
 * see http://opensource.org/licenses/MIT
 
11
 *
 
12
 * Author Gustav Hartvigsson <gustav.hartvigsson _at_ gmail.com> 2014
 
13
 */
 
14
 
 
15
struct DynamicArray {
 
16
  size_t max_size;
 
17
  size_t len;
 
18
  FreeFunc free_func;
 
19
  _pointer * array;
 
20
};
 
21
 
 
22
void _private_for_each_item_free (DynamicArray * self, _pointer item,
 
23
                                    _pointer data);
 
24
 
 
25
DynamicArray * dynamic_array_new (size_t len, FreeFunc free_func) {
 
26
  DynamicArray * self = malloc (sizeof(DynamicArray));
 
27
  
 
28
  self->max_size = len;
 
29
  self->len = 0;
 
30
  
 
31
  self->free_func = free_func;
 
32
  
 
33
  self->array = malloc (len * sizeof (* self->array));
 
34
  
 
35
  return self;
 
36
}
 
37
 
 
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
  }
 
47
  free (self->array);
 
48
  free (self);
 
49
}
 
50
 
 
51
_pointer dynamic_array_get (DynamicArray * self, size_t index) {
 
52
  return self->array[index];
 
53
}
 
54
 
 
55
size_t dynamic_array_len (DynamicArray * self) {
 
56
  return self->len;
 
57
}
 
58
 
 
59
size_t dynamic_array_size (DynamicArray * self) {
 
60
  return self->max_size;
 
61
}
 
62
 
 
63
void dynamic_array_add (DynamicArray * self, _pointer data) {
 
64
  if (self->len >= self->max_size - 1) {
 
65
    self->array = realloc (self->array,
 
66
                          (sizeof (* self->array) *
 
67
                          (self->max_size + ARRAY_PADDING)));
 
68
    self->max_size = self->max_size + ARRAY_PADDING;
 
69
  }
 
70
  self->array[self->len] = data;
 
71
  self->len++;
 
72
}
 
73
 
 
74
_pointer * dynamic_array_dump_array (DynamicArray * self) {
 
75
  _pointer * ret_val = malloc (sizeof (* self->array) * (self->len + 1));
 
76
  for (int i = 0; i < self->len; i++) {
 
77
    ret_val[i] = self->array[i];
 
78
  }
 
79
  ret_val[self->len] = NULL;
 
80
  return ret_val;
 
81
}
 
82
 
 
83
void dynamic_array_for_each (DynamicArray * self, ForEachFunc func,
 
84
                             _pointer data) {
 
85
  for (int i = 0; i < self->len; i++) {
 
86
    func (self, self->array[i], data);
 
87
  }
 
88
}
 
89
 
 
90
 
 
91
void _private_for_each_item_free (DynamicArray * self, _pointer item,
 
92
                                    _pointer data) {
 
93
  FreeFunc func = self->free_func;
 
94
  func (item);
 
95
}
 
96