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

  • Committer: Gustav Hartvigsson
  • Date: 2021-09-09 10:23:09 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20210909102309-b79pigoha67t5m92
* stuff to do with the unfinished base32 implementation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libssts/DynamicArray.c
47
47
                          FuncPointer to_json,
48
48
                          FuncPointer from_json) {
49
49
  SDynamicArray * self = s_malloc (sizeof(SDynamicArray));
50
 
 
 
50
  
51
51
  self->max_size = len;
52
 
 
 
52
  
53
53
  self->last_item = 0;
54
 
 
55
 
 
 
54
  
 
55
  
56
56
  if (free_func == NULL) {
57
57
    self->free_func = s_free;
58
58
  } else {
69
69
SDynamicArray *
70
70
s_dynamic_array_new (size_t len,
71
71
                     FreeFunc free_func) {
72
 
 
 
72
  
73
73
  SDynamicArray * self = s_dynamic_array_new_full (len, free_func, NULL, NULL);
74
 
 
 
74
  
75
75
  return self;
76
76
}
77
77
 
94
94
                                NULL);
95
95
    }
96
96
  }
97
 
 
 
97
  
98
98
  s_free (self->array);
99
99
  s_free (self);
100
100
}
117
117
  if (self->max_size <= index) {
118
118
    size_t new_size = round_up (index + ARRAY_PADDING, ARRAY_PADDING) + 1;
119
119
    s_dbg_print ("Index: %zu current array size: %zu new array size: %zu ",
120
 
      index, self->max_size, new_size);
121
 
 
 
120
                 index, self->max_size, new_size);
 
121
    
122
122
    size_t old_size = self->max_size;
123
 
 
 
123
    
124
124
    self->max_size = new_size;
125
 
 
 
125
    
126
126
    self->array = s_realloc (self->array,
127
 
                          (sizeof (spointer) * (self->max_size)));
 
127
                             (sizeof (spointer) * (self->max_size)));
128
128
    /* Zero new momery */
129
129
    for (size_t i = old_size; i < new_size; i++) {
130
130
      self->array[i] = NULL;
131
131
    }
132
132
  }
133
 
 
 
133
  
134
134
  if (self->last_item < index) {
135
135
    self->last_item = index;
136
136
  }
137
 
 
 
137
  
138
138
  self->array[index] = item;
139
139
}
140
140
 
156
156
}
157
157
 
158
158
spointer *
159
 
s_dynamic_array_dump_array (SDynamicArray * self, size_t * out_size) {
 
159
s_dynamic_array_dump_array (SDynamicArray * self,
 
160
                            size_t * out_size) {
160
161
  spointer * ret_val = s_calloc (self->last_item + 1, sizeof (* self->array));
161
162
  
162
163
  for (size_t i = 0; i <= self->last_item; i++) {
169
170
}
170
171
 
171
172
void
172
 
s_dynamic_array_for_each (SDynamicArray * self, ForEachFunc func,
173
 
                             spointer data) {
 
173
s_dynamic_array_for_each (SDynamicArray * self,
 
174
                          ForEachFunc func,
 
175
                          spointer data) {
174
176
  s_dbg_print ("Size: %zd", self->max_size);
175
177
  for (int i = 0; i < self->max_size && i <= self->last_item; i++) {
176
178
    spointer item = self->array[i];