/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 21:36:10 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20150410213610-r1q96ym4nmulpax9
* Added a few skeletal functions to Callback.h
* Re-wrote parts of SDynamicArray to be more sane.
  * removed s_dynamic_array_len() and s_dynamic_array_add()
  * added s_dynamic_array_set() and s_dynamic_array_last_item()
  * use calloc instead of malloc.
* added unsubscribe function to SGlobalNotify.
* Added decumentation in Interface.h
* Made s_dbg_print() more helpful.

-- Testing --
* Made test_case() macro more useful.
* added tests for the dynamic array.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/DynamicArray.c
41
41
  self->priv = malloc (sizeof (SDynamicArrayPrivate));
42
42
  
43
43
  self->max_size = len;
44
 
  self->len = 0;
45
44
  
46
45
  self->priv->free_func = free_func;
47
46
  
48
 
  self->priv->array = malloc (len * sizeof (* self->priv->array));
 
47
  self->priv->array = calloc (len ,sizeof (* self->priv->array));
49
48
  
50
49
  return self;
51
50
}
55
54
    s_dynamic_array_for_each (self, (ForEachFunc) _private_for_each_item_free,
56
55
                            NULL);
57
56
  } else {
58
 
    for (int i = 0; i < self->len; i++) {
 
57
    for (int i = 0; i < self->last_item; i++) {
59
58
      free (self->priv->array[i]);
60
59
    }
61
60
  }
67
66
  return self->priv->array[index];
68
67
}
69
68
 
70
 
size_t s_dynamic_array_len (SDynamicArray * self) {
71
 
  return self->len;
 
69
void s_dynamic_array_set (SDynamicArray * self, size_t index, spointer item) {
 
70
  if (self->max_size <= index) {
 
71
    size_t new_size = round_up (index + ARRAY_PADDING, ARRAY_PADDING) + 1;
 
72
    s_dbg_print ("Index: %d current array size: %d new array size: %d ",
 
73
      index, self->max_size, new_size);
 
74
    
 
75
    self->max_size = new_size;
 
76
    
 
77
    self->priv->array = realloc (self->priv->array,
 
78
                          (sizeof (* self->priv->array) * (self->max_size)));
 
79
  }
 
80
  
 
81
  if (self->last_item < index) {
 
82
    self->last_item = index;
 
83
  }
 
84
  
 
85
  self->priv->array[index] = item;
72
86
}
73
87
 
74
88
size_t s_dynamic_array_size (SDynamicArray * self) {
75
89
  return self->max_size;
76
90
}
77
91
 
78
 
void s_dynamic_array_add (SDynamicArray * self, spointer data) {
79
 
  if (self->len >= self->max_size - 1) {
80
 
    self->priv->array = realloc (self->priv->array,
81
 
                          (sizeof (* self->priv->array) *
82
 
                          (self->max_size + ARRAY_PADDING)));
83
 
    self->max_size = self->max_size + ARRAY_PADDING;
84
 
  }
85
 
  self->priv->array[self->len] = data;
86
 
  self->len++;
 
92
size_t s_dynamic_array_last_item (SDynamicArray * self) {
 
93
  return self->last_item;
87
94
}
88
95
 
89
96
spointer * s_dynamic_array_dump_array (SDynamicArray * self) {
90
 
  spointer * ret_val = malloc (sizeof (* self->priv->array) * (self->len + 1));
91
 
  for (int i = 0; i < self->len; i++) {
 
97
  spointer * ret_val = calloc (self->last_item + 1, sizeof (* self->priv->array));
 
98
  for (int i = 0; i < self->last_item; i++) {
92
99
    ret_val[i] = self->priv->array[i];
93
100
  }
94
 
  ret_val[self->len] = NULL;
 
101
  ret_val[self->last_item] = NULL;
95
102
  return ret_val;
96
103
}
97
104
 
98
105
void s_dynamic_array_for_each (SDynamicArray * self, ForEachFunc func,
99
106
                             spointer data) {
100
 
  for (int i = 0; i < self->len; i++) {
101
 
    func (self, self->priv->array[i], data);
 
107
  for (int i = 0; i < self->max_size && i <= self->last_item; i++) {
 
108
    spointer item = self->priv->array[i];
 
109
    if (item) {
 
110
      func (self, item, data);
 
111
    }
102
112
  }
103
113
}
104
114