]> git.datanom.net - lensdb.git/blob - src/csv.c
Release 0.9.3
[lensdb.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 SN,
40 MAKER,
41 LENS,
42 NOTES,
43 DATE,
44 FIELD_NUMS
45 } Fields;
46
47 struct _CsvParser {
48 gchar** header_order;
49 FILE* csv_file;
50 bool first_line_header;
51 };
52
53 static inline const gchar* stringFromFields(Fields f)
54 {
55 static const char *strings[] = { "SN", "MAKER", "LENS", "NOTES", "DATE" };
56
57 return strings[f];
58 }
59
60 static bool strv_contains(gchar** array, const gchar* s) {
61 bool equal = false;
62 gchar* s2 = g_ascii_strup(s, -1);
63 for (gchar** ptr = array; *ptr; ptr++) {
64 g_autofree gchar* s1 = g_ascii_strup(s, -1);
65 if (g_str_equal(s1, s2)) {
66 equal = true;
67 break;
68 }
69 }
70 g_free(s2);
71
72 return equal;
73 }
74
75 static gchar** parse_headers(gchar** headers) {
76 gchar** order = NULL;
77
78 GStrvBuilder* builder = g_strv_builder_new();
79 for (Fields i = SN; i < FIELD_NUMS; i++) {
80 if (strv_contains(headers, stringFromFields(i))) {
81 gchar* h = g_ascii_strup(headers[i], -1);
82 g_strv_builder_add(builder, h);
83 g_free(h);
84 }
85 }
86 order = g_strv_builder_end(builder);
87 g_strv_builder_unref(builder);
88
89 return order;
90 }
91
92 static Record* parse(CsvParser* parser, gchar** rows) {
93 Record* record = NULL;
94
95 gchar** fields = parser->header_order;
96 if (fields == NULL || rows == NULL || g_strcmp0(*rows, "") == 0) return record;
97
98 record = g_new0(Record, 1);
99 for (int i = 0; i < g_strv_length(fields); i++) {
100 gchar* elem = g_strstrip(rows[i]);
101 //fprintf(stderr, "Line: %d - %s\n", i, elem);
102 switch (i) {
103 case SN:
104 record->sn = g_strdup(elem);
105 break;
106 case MAKER:
107 record->maker = g_strdup(elem);
108 break;
109 case LENS:
110 record->data = g_strdup(elem);
111 break;
112 case NOTES:
113 record->notes = g_strdup(elem);
114 break;
115 case DATE:
116 record->date = g_strdup(elem);
117 break;
118 }
119 }
120
121 return record;
122 }
123
124 static bool open_file(CsvParser* parser, const gchar* file, bool write, bool overwrite, CvsError** error) {
125 if (write == false) {
126 if (!g_file_test(file, G_FILE_TEST_IS_REGULAR|G_FILE_TEST_EXISTS)) {
127 if (error) {
128 *error = csv_error_new();
129 (*error)->line = 0;
130 (*error)->message = g_strdup_printf("%s: File does not exists or is directory or special file", file);
131 }
132 return false;
133 }
134 parser->csv_file = g_fopen(file, "r");
135 } else {
136 if (g_file_test(file, G_FILE_TEST_EXISTS) && !overwrite) {
137 if (error) {
138 *error = csv_error_new();
139 (*error)->line = 0;
140 (*error)->message = g_strdup_printf("%s: File exists", file);
141 }
142 return false;
143 }
144 parser->csv_file = g_fopen(file, "w");
145 }
146
147 if (parser->csv_file == NULL) {
148 if (error) {
149 *error = csv_error_new();
150 (*error)->line = 0;
151 (*error)->message = g_strdup_printf("%s: File does not exists or is directory or special file", file);
152 }
153 return false;
154 }
155
156 return true;
157 }
158
159 static Record* read_next_line(CsvParser* parser, CvsError** error) {
160 Record* record = NULL;
161 gchar* buffer = g_new0(gchar, MAX_ROW);
162 gchar* line = NULL;
163 glong fields = -1;
164
165 if (!parser->csv_file) return NULL;
166
167 if (feof(parser->csv_file)) {
168 fclose(parser->csv_file);
169 parser->csv_file = NULL;
170 return NULL;
171 }
172
173 int block = 0;
174 while (fgets(buffer, MAX_ROW, parser->csv_file)) {
175 if (strlen(buffer) == MAX_ROW - 1) {
176 // more to read
177 block++;
178 if (block > 1) {
179 gchar* tmp = g_strdup_printf("%s%s", line, buffer);
180 g_free(line);
181 line = g_strdup(tmp);
182 //fprintf(stderr, "line: %s\n", line);
183 g_free(tmp);
184 } else {
185 line = g_strdup(buffer);
186 }
187 } else {
188 if (line == NULL)
189 line = g_strdup(buffer);
190 else {
191 gchar* tmp = g_strdup_printf("%s%s", line, buffer);
192 g_free(line);
193 line = g_strdup(tmp);
194 g_free(tmp);
195 }
196 gchar* c = NULL;
197 if ((c = g_strstr_len(line, -1, "\n")) != NULL)
198 line[strlen(line) - strlen(c)] = '\0';
199 break;
200 }
201 }
202 g_free(buffer);
203 if (line == NULL) return NULL;
204
205 if (parser->first_line_header) {
206 gchar** elems = parse_csv(line);
207 g_free(line);
208
209 if (elems == NULL) {
210 if (error) {
211 *error = g_new0(CvsError, 1);
212 (*error)->line = 0;
213 (*error)->message = g_strdup("Missing header row");
214 }
215 return NULL;
216 }
217
218 fields = g_strv_length(elems);
219 if (fields != FIELD_NUMS) {
220 if (error) {
221 *error = csv_error_new();
222 (*error)->line = 0;
223 (*error)->message = g_strdup_printf("Row must have %d fields", FIELD_NUMS);
224 }
225 g_strfreev(elems);
226 return NULL;
227 }
228
229 parser->header_order = parse_headers(elems);
230 g_strfreev(elems);
231
232 if (!parser->header_order || !(parser->header_order && g_strv_length(parser->header_order))) {
233 if (error) {
234 *error = csv_error_new();
235 (*error)->line = 0;
236 (*error)->message = g_strdup_printf("Row must have %d fields", FIELD_NUMS);
237 }
238 return NULL;
239 }
240
241 parser->first_line_header = false;
242
243 return read_next_line(parser, error);
244 } else {
245 gchar** elems = parse_csv(line);
246 g_free(line);
247
248 if (elems == NULL) {
249 if (error) {
250 *error = csv_error_new();
251 (*error)->line = 0;
252 (*error)->message = g_strdup("No lens info found");
253 }
254 return NULL;
255 }
256
257 if (fields >= 0 && fields != g_strv_length(elems)) {
258 if (error) {
259 *error = csv_error_new();
260 (*error)->line = 0;
261 (*error)->message = g_strdup("Header and fields mismatch");
262 }
263 g_strfreev(elems);
264 return NULL;
265 }
266
267 record = parse(parser, elems);
268
269 g_strfreev(elems);
270 }
271
272 return record;
273 }
274
275 bool csv_parser_dump_row(CsvParser* parser, const Record* row, CvsError** error) {
276 if (!parser->csv_file || row == NULL) return false;
277
278 gchar* strrow = g_strdup_printf("\"%s\",\"%s\",\"%s\",\"%s\",\"%s\"\n",
279 row->sn, row->maker, row->data, row->notes, row->date);
280 size_t expected = strlen(strrow);
281 size_t actual = fwrite(strrow, sizeof(char), expected, parser->csv_file);
282 g_free(strrow);
283
284 if (actual != expected)
285 return false;
286
287 return false;
288 }
289
290 CsvParser* csv_parser_new(Instructions* instructions, CvsError** error) {
291 CsvParser* parser = g_new0(CsvParser, 1);
292
293 parser->first_line_header = instructions->first_line_header;
294 if (! open_file(parser, instructions->file, instructions->write, instructions->write, error)) {
295 csv_parser_free(parser);
296 parser = NULL;
297 }
298 return parser;
299 }
300
301 Record* csv_parser_next_line(CsvParser* parser, CvsError** error) {
302 return read_next_line(parser, error);
303 }
304
305 CvsError* csv_error_new() {
306 CvsError* err;
307 err = g_new0(CvsError, 1);
308 return err;
309 }
310
311 void csv_parser_free(CsvParser* parser) {
312 if (parser == NULL) return;
313
314 if (parser->csv_file)
315 fclose(parser->csv_file);
316 if (parser->header_order)
317 g_strfreev(parser->header_order);
318 g_free(parser);
319 }
320
321 void csv_error_free(CvsError* error) {
322 if (error) {
323 g_free(error->message);
324 g_free(error);
325 }
326 }
327
328 void csv_error_clear(CvsError** error) {
329 if (error && *error) {
330 csv_error_free(*error);
331 *error = NULL;
332 }
333 }
334
335 void csv_record_print(Record* r) {
336 fprintf(stdout, "sn: %s maker: %s lens: %s notes: %s date added: %s\n", r->sn, r->maker, r->data, r->notes, r->date);
337 }
338
339 void csv_record_free(Record* r) {
340 if (r) {
341 g_free(r->data);
342 g_free(r->maker);
343 g_free(r->notes);
344 g_free(r->sn);
345 g_free(r->date);
346 g_free(r);
347 }
348 }
This page took 0.765021 seconds and 6 git commands to generate.