/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: 2015-04-07 08:35:51 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20150407083551-eigkistus394ds7e
* Made the code compile using CMake.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/DynamicArray.c
3
3
 * :indentSize=2:tabSize=2:noTabs=true:
4
4
 */
5
5
 
6
 
#include "DynamicArray.h"
7
 
 
8
6
/*
9
7
Copyright (c) 2013-2014 Gustav Hartvigsson
10
8
 
27
25
THE SOFTWARE.
28
26
*/
29
27
 
 
28
#include "DynamicArray.h"
 
29
 
30
30
struct DynamicArray {
31
31
  size_t max_size;
32
32
  size_t len;
33
33
  FreeFunc free_func;
34
 
  _pointer * array;
 
34
  spointer * array;
35
35
};
36
36
 
37
 
void _private_for_each_item_free (DynamicArray * self, _pointer item,
38
 
                                    _pointer data);
 
37
void _private_for_each_item_free (DynamicArray * self, spointer item,
 
38
                                    spointer data);
39
39
 
40
40
DynamicArray * dynamic_array_new (size_t len, FreeFunc free_func) {
41
41
  DynamicArray * self = malloc (sizeof(DynamicArray));
63
63
  free (self);
64
64
}
65
65
 
66
 
_pointer dynamic_array_get (DynamicArray * self, size_t index) {
 
66
spointer dynamic_array_get (DynamicArray * self, size_t index) {
67
67
  return self->array[index];
68
68
}
69
69
 
75
75
  return self->max_size;
76
76
}
77
77
 
78
 
void dynamic_array_add (DynamicArray * self, _pointer data) {
 
78
void dynamic_array_add (DynamicArray * self, spointer data) {
79
79
  if (self->len >= self->max_size - 1) {
80
80
    self->array = realloc (self->array,
81
81
                          (sizeof (* self->array) *
86
86
  self->len++;
87
87
}
88
88
 
89
 
_pointer * dynamic_array_dump_array (DynamicArray * self) {
90
 
  _pointer * ret_val = malloc (sizeof (* self->array) * (self->len + 1));
 
89
spointer * dynamic_array_dump_array (DynamicArray * self) {
 
90
  spointer * ret_val = malloc (sizeof (* self->array) * (self->len + 1));
91
91
  for (int i = 0; i < self->len; i++) {
92
92
    ret_val[i] = self->array[i];
93
93
  }
96
96
}
97
97
 
98
98
void dynamic_array_for_each (DynamicArray * self, ForEachFunc func,
99
 
                             _pointer data) {
 
99
                             spointer data) {
100
100
  for (int i = 0; i < self->len; i++) {
101
101
    func (self, self->array[i], data);
102
102
  }
103
103
}
104
104
 
105
105
 
106
 
void _private_for_each_item_free (DynamicArray * self, _pointer item,
107
 
                                    _pointer data) {
 
106
void _private_for_each_item_free (DynamicArray * self, spointer item,
 
107
                                    spointer data) {
108
108
  FreeFunc func = self->free_func;
109
109
  func (item);
110
110
}