/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-10 15:24:35 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20150410152435-uumooulvwmn02rxb
* Renamed DynamicArray to SDynamicArray.
* Renamed dynamic_array_*() functions to s_dynamic_array_*()
* Fixed indentation problem in Error.h and defs.h
* Removed dependency on stdbool.h
* Added sboolean
* Addad sconstpointer
* Reverted SMap back no not depending on SObject.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/DynamicArray.c
27
27
 
28
28
#include "DynamicArray.h"
29
29
 
30
 
struct DynamicArray {
31
 
  size_t max_size;
32
 
  size_t len;
 
30
struct SDynamicArrayPrivate {
33
31
  FreeFunc free_func;
34
32
  spointer * array;
35
33
};
36
34
 
37
 
void _private_for_each_item_free (DynamicArray * self, spointer item,
 
35
void _private_for_each_item_free (SDynamicArray * self, spointer item,
38
36
                                    spointer data);
39
37
 
40
 
DynamicArray * dynamic_array_new (size_t len, FreeFunc free_func) {
41
 
  DynamicArray * self = malloc (sizeof(DynamicArray));
 
38
SDynamicArray * s_dynamic_array_new (size_t len, FreeFunc free_func) {
 
39
  SDynamicArray * self = malloc (sizeof(SDynamicArray));
 
40
  
 
41
  self->priv = malloc (sizeof (SDynamicArrayPrivate));
42
42
  
43
43
  self->max_size = len;
44
44
  self->len = 0;
45
45
  
46
 
  self->free_func = free_func;
 
46
  self->priv->free_func = free_func;
47
47
  
48
 
  self->array = malloc (len * sizeof (* self->array));
 
48
  self->priv->array = malloc (len * sizeof (* self->priv->array));
49
49
  
50
50
  return self;
51
51
}
52
52
 
53
 
void dynamic_array_free (DynamicArray * self) {
54
 
  if (self->free_func != NULL) {
55
 
    dynamic_array_for_each (self, (ForEachFunc) _private_for_each_item_free,
 
53
void s_dynamic_array_free (SDynamicArray * self) {
 
54
  if (self->priv->free_func != NULL) {
 
55
    s_dynamic_array_for_each (self, (ForEachFunc) _private_for_each_item_free,
56
56
                            NULL);
57
57
  } else {
58
58
    for (int i = 0; i < self->len; i++) {
59
 
      free (self->array[i]);
 
59
      free (self->priv->array[i]);
60
60
    }
61
61
  }
62
 
  free (self->array);
 
62
  free (self->priv->array);
63
63
  free (self);
64
64
}
65
65
 
66
 
spointer dynamic_array_get (DynamicArray * self, size_t index) {
67
 
  return self->array[index];
 
66
spointer s_dynamic_array_get (SDynamicArray * self, size_t index) {
 
67
  return self->priv->array[index];
68
68
}
69
69
 
70
 
size_t dynamic_array_len (DynamicArray * self) {
 
70
size_t s_dynamic_array_len (SDynamicArray * self) {
71
71
  return self->len;
72
72
}
73
73
 
74
 
size_t dynamic_array_size (DynamicArray * self) {
 
74
size_t s_dynamic_array_size (SDynamicArray * self) {
75
75
  return self->max_size;
76
76
}
77
77
 
78
 
void dynamic_array_add (DynamicArray * self, spointer data) {
 
78
void s_dynamic_array_add (SDynamicArray * self, spointer data) {
79
79
  if (self->len >= self->max_size - 1) {
80
 
    self->array = realloc (self->array,
81
 
                          (sizeof (* self->array) *
 
80
    self->priv->array = realloc (self->priv->array,
 
81
                          (sizeof (* self->priv->array) *
82
82
                          (self->max_size + ARRAY_PADDING)));
83
83
    self->max_size = self->max_size + ARRAY_PADDING;
84
84
  }
85
 
  self->array[self->len] = data;
 
85
  self->priv->array[self->len] = data;
86
86
  self->len++;
87
87
}
88
88
 
89
 
spointer * dynamic_array_dump_array (DynamicArray * self) {
90
 
  spointer * ret_val = malloc (sizeof (* self->array) * (self->len + 1));
 
89
spointer * s_dynamic_array_dump_array (SDynamicArray * self) {
 
90
  spointer * ret_val = malloc (sizeof (* self->priv->array) * (self->len + 1));
91
91
  for (int i = 0; i < self->len; i++) {
92
 
    ret_val[i] = self->array[i];
 
92
    ret_val[i] = self->priv->array[i];
93
93
  }
94
94
  ret_val[self->len] = NULL;
95
95
  return ret_val;
96
96
}
97
97
 
98
 
void dynamic_array_for_each (DynamicArray * self, ForEachFunc func,
 
98
void s_dynamic_array_for_each (SDynamicArray * self, ForEachFunc func,
99
99
                             spointer data) {
100
100
  for (int i = 0; i < self->len; i++) {
101
 
    func (self, self->array[i], data);
 
101
    func (self, self->priv->array[i], data);
102
102
  }
103
103
}
104
104
 
105
105
 
106
 
void _private_for_each_item_free (DynamicArray * self, spointer item,
 
106
void _private_for_each_item_free (SDynamicArray * self, spointer item,
107
107
                                    spointer data) {
108
 
  FreeFunc func = self->free_func;
 
108
  FreeFunc func = self->priv->free_func;
109
109
  func (item);
110
110
}
111
111