src/storage/storage.c

   1 #include <stdlib.h>
   2
   3 #include "storage.h"
   4
   5 #include "../debug.h"
   6
   7 struct familia_storage * _familia_storage_current;
   8
   9 struct familia_storage * familia_storage_get_current()
  10 {
  11         return _familia_storage_current;
  12 }
  13
  14 void familia_storage_set_current(struct familia_storage * storage)
  15 {
  16         _familia_storage_current = storage;
  17 }
  18
  19 struct familia_storage * familia_storage_new()
  20 {
  21         struct familia_storage * storage = NULL;
  22         storage = malloc(sizeof(struct familia_storage));
  23
  24         if (!storage) {
  25                 debug("["__FILE__ "] There was a problem with allocating memory for storage.\n");
  26                 return NULL;
  27         }
  28
  29         storage->individuals = NULL;
  30         storage->individuals_no = 0;
  31         storage->families = NULL;
  32         storage->families_no = 0;
  33
  34         return storage;
  35 }
  36
  37 void familia_storage_free(struct familia_storage * storage)
  38 {
  39         unsigned int i = 0;
  40
  41         if (storage->individuals_no) {
  42                 for (i = 0; i < storage->individuals_no; i++) {
  43                         familia_individual_free(storage->individuals[i]);
  44                         storage->individuals[i] = NULL;
  45                 }
  46                 free(storage->individuals);
  47                 storage->individuals = NULL;
  48                 storage->individuals_no = 0;
  49         }
  50
  51         if (storage->families_no) {
  52                 for (i = 0; i < storage->families_no; i++) {
  53                         familia_family_free(storage->families[i]);
  54                         storage->families[i] = NULL;
  55                 }
  56                 free(storage->families);
  57                 storage->families = NULL;
  58                 storage->families_no = 0;
  59         }
  60 }
  61
  62 void familia_storage_add_individual(struct familia_storage * storage, struct familia_individual * individual)
  63 {
  64         struct familia_individual ** tmp = NULL;
  65         int size = (storage->individuals_no + 1);
  66
  67         if (individual) {
  68                 tmp = realloc(storage->individuals, size * sizeof(struct familia_individual *));
  69
  70                 if (tmp) {
  71                         storage->individuals = tmp;
  72                         storage->individuals[storage->individuals_no] = individual;
  73                         storage->individuals_no++;
  74                 }
  75                 else {
  76                         debug("["__FILE__ "] There were problems with allocating memory for individual.\n");
  77                 }
  78         }
  79 }
  80
  81 struct familia_individual * familia_storage_get_individual_by_id(struct familia_storage * storage, unsigned int id)
  82 {
  83         if (storage->individuals_no < id) {
  84                 debug("["__FILE__ "Trying to get not existing individual!\n");
  85                 return NULL;
  86         }
  87         return storage->individuals[id];
  88 }
  89
  90 void familia_storage_remove_individual_by_id(struct familia_storage * storage, unsigned int id)
  91 {
  92         unsigned int i = 0;
  93         int found = 0;
  94         struct familia_individual ** tmp = NULL;
  95
  96         if (storage->individuals_no < id) {
  97                 debug("["__FILE__ "] Trying to remove not existing individual!\n");
  98                 return;
  99         }
 100
 101         for (i = 0; i < storage->individuals_no; i++) {
 102                 if (storage->individuals[i]->id == id) {
 103                         found = 1;
 104                         familia_individual_free(storage->individuals[i]);
 105                         storage->individuals[i] = NULL;
 106                 }
 107
 108                 /*
 109                  * If family has been found, reorder rest of files to avoid
 110                  * NULL pointers inside array.
 111                  */
 112                 if (found && (i < storage->individuals_no - 1)) {
 113                         storage->individuals[i] = storage->individuals[i + 1];
 114                 }
 115         }
 116
 117         if (found) {
 118                 tmp = realloc(storage->individuals,
 119                         (storage->families_no) * sizeof(struct familia_family *));
 120
 121                 if (tmp) {
 122                         storage->individuals = tmp;
 123                 }
 124                 storage->individuals_no--;
 125         }
 126 }
 127
 128 void familia_storage_add_family(struct familia_storage * storage, struct familia_family * family)
 129 {
 130         struct familia_family ** tmp = NULL;
 131         int size = (storage->families_no + 1);
 132
 133         if (family) {
 134                 tmp = realloc(storage->families, size * sizeof(struct familia_family *));
 135
 136                 if (tmp) {
 137                         storage->families = tmp;
 138                         storage->families[storage->families_no] = family;
 139                         storage->families_no++;
 140                 }
 141                 else {
 142                         debug("["__FILE__ "] There were problems with allocating memory for family.\n");
 143                 }
 144         }
 145 }
 146
 147 struct familia_family * familia_storage_get_family_by_id(struct familia_storage * storage, unsigned int id)
 148 {
 149         if (storage->families_no < id) {
 150                 debug("["__FILE__ "Trying to get not existing family!\n");
 151                 return NULL;
 152         }
 153         return storage->families[id];
 154 }
 155
 156 void familia_storage_remove_family_by_id(struct familia_storage * storage, unsigned int id)
 157 {
 158         unsigned int i = 0;
 159         int found = 0;
 160         struct familia_family ** tmp = NULL;
 161
 162         if (storage->families_no < id) {
 163                 debug("["__FILE__ "] Trying to remove not existing family!\n");
 164                 return;
 165         }
 166
 167         for (i = 0; i < storage->families_no; i++) {
 168                 if (storage->families[i]->id == id) {
 169                         found = 1;
 170                         familia_family_free(storage->families[i]);
 171                         storage->families[i] = NULL;
 172                 }
 173
 174                 /*
 175                  * If family has been found, reorder rest of files to avoid
 176                  * NULL pointers inside array.
 177                  */
 178                 if (found && (i < storage->families_no - 1)) {
 179                         storage->families[i] = storage->families[i + 1];
 180                 }
 181         }
 182
 183         if (found) {
 184                 tmp = realloc(storage->families,
 185                         (storage->families_no) * sizeof(struct familia_family *));
 186
 187                 if (tmp) {
 188                         storage->families = tmp;
 189                 }
 190                 storage->families_no--;
 191         }
 192 }
 193