DistributedTable/data.c at master · vascoorey/DistributedTable · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
/*
 * File:   data.c
 *
 * Implementação da struct data_t
 *
 * Author: sd001 > Bruno Neves, n.º 31614
 *               > Vasco Orey,  n.º 32550
 */

#include "utils.h"
#include "data.h"

/*
 * Um construtor que cria o data_t e aloca a quantidade de memória requisitada
 * no parâmetro size para data.
 */
struct data_t *data_create(int size) {

    struct data_t *new_data = NULL;

    if(!(new_data = malloc(sizeof(struct data_t)))) {
        ERROR("Malloc new_data");
    }
    else if (size > 0) {
        if(!(new_data->data = (char*)malloc(size))) {
            ERROR("Malloc new_data->data");
            //Como não conseguimos allocar o tamanho para os dados libertamos
            //tudo o que allocamos
            free(new_data);
            new_data = NULL; // Just in case...
        }
        else {
            new_data->datasize = size;
            //Inicializar a zona de memória a 0's para não termos reads invalidos ;)
            memset(new_data->data,0,size);
            new_data->timestamp = 0;
        }
    }
    //No caso da data ser NULL
    else if (!size) {
		if(!(new_data->data = malloc(1))) {
			ERROR("malloc");
			return NULL;
		}
        memcpy(new_data->data, "0", 1);
		new_data->datasize = 1;
		new_data->timestamp = 0;
    }
    else {
        ERROR("data_create");
        free(new_data);
        new_data = NULL;
    }

    //Se tudo OK então retorna um apontador válido, se não retorna NULL.
    //Retorna NULL se deu erro. Iremos usar o *data, logo fazemos free dele no
    //data_destroy
    return new_data;

}

/*
 * Um construtor que cria o data_t com o data e o datasize passados como
 * parâmetros (i.e., o data da struct vai apontar para o parâmetro data).
 */
struct data_t *data_create2(int datasize, void *data) {

    struct data_t *newData = NULL;

    //No caso da data ser NULL
    if(!datasize) {
        return data_create(0);
    }
    else if((newData = (struct data_t*)malloc(sizeof(struct data_t)))) {
        newData->datasize = datasize;
        newData->data = data;
        newData->timestamp = 0;
    }
    else {
        ERROR("malloc newData");
    }
    return newData;

}

/*
 * Cria uma *cópia* do data_t passado (incluindo o data->data).
 */
struct data_t *data_dup(struct data_t *data) {

    struct data_t *dup = NULL;

    if(data) {
        if(!(dup = data_create(data->datasize))) {
            ERROR("data_create");
        }
        //Verifica se o data está a null
        else if(data->data) {
            memcpy(dup->data, data->data, data->datasize);
            if((memcmp(dup->data, data->data, data->datasize)) != 0) {
                ERROR("memcpy");
                data_destroy(dup);
            }
            dup->timestamp = data->timestamp;
        }
        else {
            //Este data->data = NULL então fazemos o mesmo para o dup.
            dup->data = NULL;
            dup->timestamp = data->timestamp;
        }
    }
    else {
        ERROR("NULL data");
    }
    return dup;

}

/*
 * Liberta a memória de um data_t (incluindo data->data).
 */
void data_destroy(struct data_t *data) {
	if(data) {
		if(data->data)
			free(data->data);
		free(data);
		data = NULL;
    }
}