/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-08-31 14:19:49 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20150831141949-pn1p83pgcbzbfm8x
* Hid internals of SDynamicArray.
* Added s_dynamic_array_serialize_json() and s_dynamic_array_deserialize_json()
* Added s_dynamic_array_new_json()
* Added _s_dynamic_array_new_full() internal function.

* Changed SOobject's base to_string method.
* Changed testcase for to_string method.

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 SDynamicArrayPrivate {
 
30
struct
 
31
SDynamicArray {
31
32
  FreeFunc free_func;
 
33
  FuncPointer to_json;
 
34
  FuncPointer from_json;
 
35
  size_t max_size;
 
36
  size_t last_item;
32
37
  spointer * array;
33
38
};
34
39
 
35
40
void
36
41
_private_for_each_item_free (SDynamicArray * self, spointer item,
37
 
                                    spointer data);
 
42
                             spointer data);
38
43
 
39
 
SDynamicArray * s_dynamic_array_new (size_t len, FreeFunc free_func) {
 
44
SDynamicArray *
 
45
_s_dynamic_array_new_full (size_t len,
 
46
                          FreeFunc free_func,
 
47
                          FuncPointer to_json,
 
48
                          FuncPointer from_json) {
40
49
  SDynamicArray * self = malloc (sizeof(SDynamicArray));
41
50
  
42
 
  self->priv = malloc (sizeof (SDynamicArrayPrivate));
43
 
  
44
51
  self->max_size = len;
45
52
  
46
53
  self->last_item = 0;
47
54
  
48
 
  self->priv->free_func = free_func;
49
 
  
50
 
  self->priv->array = calloc (len ,sizeof (* self->priv->array));
51
 
  
 
55
  self->free_func = free_func;
 
56
  self->to_json = to_json;
 
57
  self->from_json = from_json;
 
58
  
 
59
  self->array = calloc (len ,sizeof (* self->array));
 
60
  
 
61
  return self;
 
62
}
 
63
 
 
64
SDynamicArray *
 
65
s_dynamic_array_new (size_t len,
 
66
                     FreeFunc free_func) {
 
67
  SDynamicArray * self = _s_dynamic_array_new_full (len, free_func, NULL, NULL);
 
68
  return self;
 
69
}
 
70
 
 
71
SDynamicArray *
 
72
s_dynamic_array_new_json (size_t len,
 
73
                          FreeFunc free_func,
 
74
                          FuncPointer to_json,
 
75
                          FuncPointer from_json) {
 
76
  SDynamicArray * self = _s_dynamic_array_new_full (len, free_func, to_json, from_json);
52
77
  return self;
53
78
}
54
79
 
55
80
void
56
81
s_dynamic_array_free (SDynamicArray * self, sboolean free_data) {
57
82
  if (free_data) {
58
 
    if (self->priv->free_func != NULL) {
 
83
    if (self->free_func != NULL) {
59
84
      s_dynamic_array_for_each (self, (ForEachFunc) _private_for_each_item_free,
60
85
                              NULL);
61
86
    } else {
62
87
      for (int i = 0; i < self->last_item; i++) {
63
 
        free (self->priv->array[i]);
 
88
        free (self->array[i]);
64
89
      }
65
90
    }
66
91
  }
67
92
  
68
 
  free (self->priv->array);
69
 
  free (self->priv);
 
93
  free (self->array);
70
94
  free (self);
71
95
}
72
96
 
73
97
spointer
74
98
s_dynamic_array_get (SDynamicArray * self, size_t index) {
75
 
  return self->priv->array[index];
 
99
  return self->array[index];
76
100
}
77
101
 
78
102
void
84
108
    
85
109
    self->max_size = new_size;
86
110
    
87
 
    self->priv->array = realloc (self->priv->array,
88
 
                          (sizeof (* self->priv->array) * (self->max_size)));
 
111
    self->array = realloc (self->array,
 
112
                          (sizeof (* self->array) * (self->max_size)));
89
113
  }
90
114
  
91
115
  if (self->last_item < index) {
92
116
    self->last_item = index;
93
117
  }
94
118
  
95
 
  self->priv->array[index] = item;
 
119
  self->array[index] = item;
96
120
}
97
121
 
98
122
size_t
107
131
 
108
132
spointer *
109
133
s_dynamic_array_dump_array (SDynamicArray * self) {
110
 
  spointer * ret_val = calloc (self->last_item + 1, sizeof (* self->priv->array));
 
134
  spointer * ret_val = calloc (self->last_item + 1, sizeof (* self->array));
111
135
  for (int i = 0; i < self->last_item; i++) {
112
 
    ret_val[i] = self->priv->array[i];
 
136
    ret_val[i] = self->array[i];
113
137
  }
114
138
  ret_val[self->last_item] = NULL;
115
139
  return ret_val;
119
143
s_dynamic_array_for_each (SDynamicArray * self, ForEachFunc func,
120
144
                             spointer data) {
121
145
  for (int i = 0; i < self->max_size && i <= self->last_item; i++) {
122
 
    spointer item = self->priv->array[i];
 
146
    spointer item = self->array[i];
123
147
    if (item) {
124
148
      func (self, item, data);
125
149
    }
129
153
 
130
154
void
131
155
_private_for_each_item_free (SDynamicArray * self, spointer item,
132
 
                                    spointer data) {
133
 
  FreeFunc func = self->priv->free_func;
 
156
                             spointer data) {
 
157
  FreeFunc func = self->free_func;
134
158
  func (item);
135
159
}
136
160