]> git.datanom.net - gtk_lensdatabase.git/blob - src/csv.c
On the way
[gtk_lensdatabase.git] / src / csv.c
1 /*
2 * csv.c
3 *
4 * Copyright 2024 Michael Rasmussen <mir@datanom.net>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
19 * MA 02110-1301, USA.
20 *
21 *
22 */
23
24 #include "csv.h"
25 #include "csv-parser/csv-parser.h"
26 #include <glib/gstdio.h>
27 #include <stdio.h>
28 #include <string.h>
29
30 #define MAX_ROW 500
31 #define delim ","
32 #define removechar2 "\"\""
33 #define removechar1 "\""
34 #define removechar "\""
35
36 //static FILE* csv_file = NULL;
37
38 typedef enum {
39 ID,
40 SN,
41 MAKER,
42 LENS,
43 NOTES,
44 DATE,
45 FIELD_NUMS
46 } Fields;
47
48 struct _CsvParser {
49 gchar** header_order;
50 FILE* csv_file;
51 bool first_line_header;
52 };
53
54 static inline const gchar* stringFromFields(Fields f)
55 {
56 static const char *strings[] = { "ID", "SN", "MAKER", "LENS", "NOTES", "DATE" };
57
58 return strings[f];
59 }
60
61 static bool strv_contains(gchar** array, const gchar* s) {
62 bool equal = false;
63 gchar* s2 = g_ascii_strup(s, -1);
64 for (gchar** ptr = array; *ptr; ptr++) {
65 g_autofree gchar* s1 = g_ascii_strup(s, -1);
66 if (g_str_equal(s1, s2)) {
67 equal = true;
68 break;
69 }
70 }
71 g_free(s2);
72
73 return equal;
74 }
75
76 static gchar** parse_headers(gchar** headers) {
77 gchar** order = NULL;
78
79 GStrvBuilder* builder = g_strv_builder_new();
80 for (Fields i = SN; i < FIELD_NUMS; i++) {
81 if (strv_contains(headers, stringFromFields(i))) {
82 gchar* h = g_ascii_strup(headers[i], -1);
83 g_strv_builder_add(builder, h);
84 g_free(h);
85 }
86 }
87 order = g_strv_builder_end(builder);
88 g_strv_builder_unref(builder);
89
90 return order;
91 }
92
93 static Record* parse(CsvParser* parser, gchar** rows) {
94 Record* record = NULL;
95
96 gchar** fields = parser->header_order;
97 if (fields == NULL || rows == NULL || g_strcmp0(*rows, "") == 0) return record;
98
99 record = g_new0(Record, 1);
100 for (int i = 0; i < g_strv_length(fields); i++) {
101 gchar* elem = g_strstrip(rows[i]);
102 //fprintf(stderr, "Line: %d - %s\n", i, elem);
103 switch (i) {
104 case SN:
105 record->sn = g_strdup(elem);
106 break;
107 case MAKER:
108 record->maker = g_strdup(elem);
109 break;
110 case LENS:
111 record->data = g_strdup(elem);
112 break;
113 case NOTES:
114 record->notes = g_strdup(elem);
115 break;
116 case DATE:
117 record->date = g_strdup(elem);
118 break;
119 }
120 }
121
122 return record;
123 }
124
125 static bool open_file(CsvParser* parser, const gchar* file, bool write, bool overwrite, CvsError** error) {
126 if (write == false) {
127 if (!g_file_test(file, G_FILE_TEST_IS_REGULAR|G_FILE_TEST_EXISTS)) {
128 if (error) {
129 *error = csv_error_new();
130 (*error)->line = 0;
131 (*error)->message = g_strdup_printf("%s: File does not exists or is directory or special file", file);
132 }
133 return false;
134 }
135 parser->csv_file = g_fopen(file, "r");
136 } else {
137 if (g_file_test(file, G_FILE_TEST_EXISTS) && !overwrite) {
138 if (error) {
139 *error = csv_error_new();
140 (*error)->line = 0;
141 (*error)->message = g_strdup_printf("%s: File exists", file);
142 }
143 return false;
144 }
145 parser->csv_file = g_fopen(file, "w");
146 }
147
148 if (parser->csv_file == NULL) {
149 if (error) {
150 *error = csv_error_new();
151 (*error)->line = 0;
152 (*error)->message = g_strdup_printf("%s: File does not exists or is directory or special file", file);
153 }
154 return false;
155 }
156
157 return true;
158 }
159
160 static Record* read_next_line(CsvParser* parser, CvsError** error) {
161 Record* record = NULL;
162 gchar* buffer = g_new0(gchar, MAX_ROW);
163 gchar* line = NULL;
164 glong fields = -1;
165
166 if (!parser->csv_file) return NULL;
167
168 if (feof(parser->csv_file)) {
169 fclose(parser->csv_file);
170 parser->csv_file = NULL;
171 return NULL;
172 }
173
174 int block = 0;
175 while (fgets(buffer, MAX_ROW, parser->csv_file)) {
176 if (strlen(buffer) == MAX_ROW - 1) {
177 // more to read
178 block++;
179 if (block > 1) {
180 gchar* tmp = g_strdup_printf("%s%s", line, buffer);
181 g_free(line);
182 line = g_strdup(tmp);
183 //fprintf(stderr, "line: %s\n", line);
184 g_free(tmp);
185 } else {
186 line = g_strdup(buffer);
187 }
188 } else {
189 if (line == NULL)
190 line = g_strdup(buffer);
191 else {
192 gchar* tmp = g_strdup_printf("%s%s", line, buffer);
193 g_free(line);
194 line = g_strdup(tmp);
195 g_free(tmp);
196 }
197 gchar* c = NULL;
198 if ((c = g_strstr_len(line, -1, "\n")) != NULL)
199 line[strlen(line) - strlen(c)] = '\0';
200 break;
201 }
202 }
203 g_free(buffer);
204 if (line == NULL) return NULL;
205
206 if (parser->first_line_header) {
207 gchar** elems = parse_csv(line);
208 g_free(line);
209
210 if (elems == NULL) {
211 if (error) {
212 *error = g_new0(CvsError, 1);
213 (*error)->line = 0;
214 (*error)->message = g_strdup("Missing header row");
215 }
216 return NULL;
217 }
218
219 fields = g_strv_length(elems);
220 if (fields != FIELD_NUMS) {
221 if (error) {
222 *error = csv_error_new();
223 (*error)->line = 0;
224 (*error)->message = g_strdup_printf("Row must have %d fields", FIELD_NUMS);
225 }
226 g_strfreev(elems);
227 return NULL;
228 }
229
230 parser->header_order = parse_headers(elems);
231 g_strfreev(elems);
232
233 if (!parser->header_order || !(parser->header_order && g_strv_length(parser->header_order))) {
234 if (error) {
235 *error = csv_error_new();
236 (*error)->line = 0;
237 (*error)->message = g_strdup_printf("Row must have %d fields", FIELD_NUMS);
238 }
239 return NULL;
240 }
241
242 parser->first_line_header = false;
243
244 return read_next_line(parser, error);
245 } else {
246 gchar** elems = parse_csv(line);
247 g_free(line);
248
249 if (elems == NULL) {
250 if (error) {
251 *error = csv_error_new();
252 (*error)->line = 0;
253 (*error)->message = g_strdup("No lens info found");
254 }
255 return NULL;
256 }
257
258 if (fields >= 0 && fields != g_strv_length(elems)) {
259 if (error) {
260 *error = csv_error_new();
261 (*error)->line = 0;
262 (*error)->message = g_strdup("Header and fields mismatch");
263 }
264 g_strfreev(elems);
265 return NULL;
266 }
267
268 record = parse(parser, elems);
269
270 g_strfreev(elems);
271 }
272
273 return record;
274 }
275
276 bool csv_parser_dump_row(CsvParser* parser, const Record* row, CvsError** error) {
277 if (!parser->csv_file || row == NULL) return false;
278
279 gchar* strrow = g_strdup_printf("\"%s\",\"%s\",\"%s\",\"%s\",\"%s\"\n",
280 row->sn, row->maker, row->data, row->notes, row->date);
281 size_t expected = strlen(strrow);
282 size_t actual = fwrite(strrow, sizeof(char), expected, parser->csv_file);
283 g_free(strrow);
284
285 if (actual != expected)
286 return false;
287
288 return false;
289 }
290
291 CsvParser* csv_parser_new(Instructions* instructions, CvsError** error) {
292 CsvParser* parser = g_new0(CsvParser, 1);
293
294 parser->first_line_header = instructions->first_line_header;
295 if (! open_file(parser, instructions->file, instructions->write, instructions->write, error)) {
296 csv_parser_free(parser);
297 parser = NULL;
298 }
299 return parser;
300 }
301
302 Record* csv_parser_next_line(CsvParser* parser, CvsError** error) {
303 return read_next_line(parser, error);
304 }
305
306 CvsError* csv_error_new() {
307 CvsError* err;
308 err = g_new0(CvsError, 1);
309 return err;
310 }
311
312 void csv_parser_free(CsvParser* parser) {
313 if (parser == NULL) return;
314
315 if (parser->csv_file)
316 fclose(parser->csv_file);
317 if (parser->header_order)
318 g_strfreev(parser->header_order);
319 g_free(parser);
320 }
321
322 void csv_error_free(CvsError* error) {
323 if (error) {
324 g_free(error->message);
325 g_free(error);
326 }
327 }
328
329 void csv_error_clear(CvsError** error) {
330 if (error && *error) {
331 csv_error_free(*error);
332 *error = NULL;
333 }
334 }
335
336 void csv_record_print(Record* r) {
337 fprintf(stdout, "sn: %s maker: %s lens: %s notes: %s date added: %s\n", r->sn, r->maker, r->data, r->notes, r->date);
338 }
339
340 void csv_record_free(Record* r) {
341 if (r) {
342 g_free(r->data);
343 g_free(r->maker);
344 g_free(r->notes);
345 g_free(r->sn);
346 g_free(r->date);
347 g_free(r);
348 }
349 }
This page took 0.648219 seconds and 6 git commands to generate.