Line data Source code
1 : /* File: json_element_reader.c; Copyright and License: see below */
2 :
3 : #include "json/json_element_reader.h"
4 : #include "u8/u8_trace.h"
5 : #include "u8/u8_log.h"
6 : #include <assert.h>
7 :
8 21 : void json_element_reader_init ( json_element_reader_t *this_, universal_input_stream_t *in_data )
9 : {
10 21 : U8_TRACE_BEGIN();
11 21 : assert( NULL != in_data );
12 :
13 21 : (*this_).temp_string = utf8stringbuf_new( (*this_).temp_string_buffer, sizeof((*this_).temp_string_buffer) );
14 :
15 21 : json_token_reader_init( &((*this_).tokenizer), in_data );
16 :
17 21 : (*this_).top_array_after_first_entry = false;
18 21 : (*this_).sub_array_after_first_entry = false;
19 :
20 21 : U8_TRACE_END();
21 21 : }
22 :
23 0 : void json_element_reader_reinit ( json_element_reader_t *this_, universal_input_stream_t *in_data )
24 : {
25 0 : U8_TRACE_BEGIN();
26 0 : assert( NULL != in_data );
27 :
28 0 : json_element_reader_destroy( this_ );
29 0 : json_element_reader_init( this_, in_data );
30 :
31 0 : U8_TRACE_END();
32 0 : }
33 :
34 21 : void json_element_reader_destroy ( json_element_reader_t *this_ )
35 : {
36 21 : U8_TRACE_BEGIN();
37 :
38 21 : json_token_reader_destroy( &((*this_).tokenizer) );
39 :
40 21 : U8_TRACE_END();
41 21 : }
42 :
43 21 : u8_error_t json_element_reader_expect_header ( json_element_reader_t *this_ )
44 : {
45 21 : U8_TRACE_BEGIN();
46 21 : u8_error_t result = U8_ERROR_NONE;
47 21 : char member_name_buf[24] = "";
48 21 : utf8stringbuf_t member_name = UTF8STRINGBUF( member_name_buf );
49 :
50 21 : result = json_token_reader_expect_begin_object ( &((*this_).tokenizer) );
51 :
52 21 : if ( U8_ERROR_NONE == result )
53 : {
54 20 : result = json_token_reader_read_member_name ( &((*this_).tokenizer), member_name );
55 20 : if ( ! utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_HEAD ) )
56 : {
57 0 : U8_LOG_ERROR_INT( "unexpected object contents at line",
58 : json_token_reader_get_input_line( &((*this_).tokenizer) )
59 : );
60 0 : result |= U8_ERROR_PARSER_STRUCTURE;
61 : }
62 : }
63 :
64 21 : if ( U8_ERROR_NONE == result )
65 : {
66 20 : result = json_token_reader_expect_name_separator( &((*this_).tokenizer) );
67 : }
68 :
69 21 : if ( U8_ERROR_NONE == result )
70 : {
71 20 : result = json_element_reader_skip_next_object( this_ );
72 : }
73 :
74 21 : U8_TRACE_END_ERR( result );
75 21 : return result;
76 : }
77 :
78 55 : u8_error_t json_element_reader_expect_begin_top_array ( json_element_reader_t *this_ )
79 : {
80 55 : U8_TRACE_BEGIN();
81 55 : u8_error_t result = U8_ERROR_NONE;
82 55 : char member_name_buf[24] = "";
83 55 : utf8stringbuf_t member_name = UTF8STRINGBUF( member_name_buf );
84 :
85 55 : result = json_token_reader_expect_value_separator ( &((*this_).tokenizer) );
86 :
87 55 : if ( U8_ERROR_NONE == result )
88 : {
89 55 : result = json_token_reader_read_member_name ( &((*this_).tokenizer), member_name );
90 55 : if (( ! utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_VIEWS ) )
91 35 : && ( ! utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_NODES ) )
92 17 : && ( ! utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_EDGES ) ))
93 : {
94 0 : U8_LOG_ERROR_INT( "unexpected object contents at line",
95 : json_token_reader_get_input_line( &((*this_).tokenizer) )
96 : );
97 0 : result |= U8_ERROR_PARSER_STRUCTURE;
98 : }
99 : }
100 :
101 55 : if ( U8_ERROR_NONE == result )
102 : {
103 55 : result = json_token_reader_expect_name_separator( &((*this_).tokenizer) );
104 : }
105 :
106 55 : if ( U8_ERROR_NONE == result )
107 : {
108 55 : result = json_token_reader_expect_begin_array( &((*this_).tokenizer) );
109 : }
110 :
111 55 : U8_TRACE_END_ERR( result );
112 55 : return result;
113 : }
114 :
115 14 : u8_error_t json_element_reader_expect_footer ( json_element_reader_t *this_ )
116 : {
117 14 : U8_TRACE_BEGIN();
118 14 : u8_error_t result = U8_ERROR_NONE;
119 :
120 : bool end_ok;
121 14 : result = json_token_reader_check_end_object ( &((*this_).tokenizer), &end_ok );
122 14 : if ( ! end_ok )
123 : {
124 0 : U8_LOG_ERROR_INT( "unexpected object contents at line",
125 : json_token_reader_get_input_line( &((*this_).tokenizer) )
126 : );
127 0 : result |= U8_ERROR_PARSER_STRUCTURE;
128 : }
129 :
130 14 : if ( U8_ERROR_NONE == result )
131 : {
132 14 : result = json_token_reader_expect_eof ( &((*this_).tokenizer) );
133 : }
134 :
135 14 : U8_TRACE_END_ERR( result );
136 14 : return result;
137 : }
138 :
139 86 : u8_error_t json_element_reader_check_end_top_array ( json_element_reader_t *this_, bool* out_end )
140 : {
141 86 : U8_TRACE_BEGIN();
142 86 : assert( NULL != out_end );
143 86 : u8_error_t result = U8_ERROR_NONE;
144 :
145 86 : result = json_token_reader_check_end_array ( &((*this_).tokenizer), out_end );
146 :
147 86 : if (( U8_ERROR_NONE == result ) && ( *out_end ))
148 : {
149 49 : (*this_).top_array_after_first_entry = false;
150 : }
151 :
152 86 : U8_TRACE_END_ERR( result );
153 86 : return result;
154 : }
155 :
156 20 : u8_error_t json_element_reader_expect_begin_sub_array ( json_element_reader_t *this_ )
157 : {
158 20 : U8_TRACE_BEGIN();
159 20 : u8_error_t result = U8_ERROR_NONE;
160 :
161 20 : result = json_token_reader_expect_begin_array( &((*this_).tokenizer) );
162 20 : if ( U8_ERROR_NONE == result )
163 : {
164 20 : (*this_).sub_array_after_first_entry = false;
165 : }
166 :
167 20 : U8_TRACE_END_ERR( result );
168 20 : return result;
169 : }
170 :
171 49 : u8_error_t json_element_reader_check_end_sub_array ( json_element_reader_t *this_, bool* out_end )
172 : {
173 49 : U8_TRACE_BEGIN();
174 49 : assert( NULL != out_end );
175 49 : u8_error_t result = U8_ERROR_NONE;
176 :
177 49 : result = json_token_reader_check_end_array ( &((*this_).tokenizer), out_end );
178 :
179 49 : if ( U8_ERROR_NONE == result )
180 : {
181 49 : if ( *out_end )
182 : {
183 20 : (*this_).sub_array_after_first_entry = false;
184 : }
185 : else
186 : {
187 29 : if ( (*this_).sub_array_after_first_entry )
188 : {
189 11 : result = json_token_reader_expect_value_separator ( &((*this_).tokenizer) );
190 : }
191 : else
192 : {
193 18 : (*this_).sub_array_after_first_entry = true;
194 : }
195 : }
196 : }
197 :
198 49 : U8_TRACE_END_ERR( result );
199 49 : return result;
200 : }
201 :
202 37 : u8_error_t json_element_reader_expect_begin_type_of_element ( json_element_reader_t *this_, data_table_t *out_type )
203 : {
204 37 : U8_TRACE_BEGIN();
205 37 : assert ( NULL != out_type );
206 37 : u8_error_t result = U8_ERROR_NONE;
207 :
208 : bool array_end;
209 : char member_name_buf[24];
210 37 : utf8stringbuf_t member_name = UTF8STRINGBUF( member_name_buf );
211 :
212 37 : result = json_token_reader_check_end_array ( &((*this_).tokenizer), &array_end );
213 :
214 37 : if ( U8_ERROR_NONE == result )
215 : {
216 37 : if ( array_end )
217 : {
218 0 : (*out_type) = DATA_TABLE_VOID;
219 : }
220 : else
221 : {
222 37 : if ( (*this_).top_array_after_first_entry )
223 : {
224 1 : result = json_token_reader_expect_value_separator ( &((*this_).tokenizer) );
225 : }
226 : else
227 : {
228 36 : (*this_).top_array_after_first_entry = true;
229 : }
230 37 : if ( U8_ERROR_NONE == result )
231 : {
232 37 : result = json_token_reader_expect_begin_object ( &((*this_).tokenizer) );
233 : }
234 37 : if ( U8_ERROR_NONE == result )
235 : {
236 37 : result = json_token_reader_read_member_name ( &((*this_).tokenizer), member_name );
237 : }
238 37 : if ( U8_ERROR_NONE == result )
239 : {
240 37 : if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAM ) )
241 : {
242 9 : (*out_type) = DATA_TABLE_DIAGRAM;
243 : }
244 : /*
245 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAMELEMENT ) )
246 : {
247 : (*out_type) = DATA_TABLE_DIAGRAMELEMENT;
248 : }
249 : */
250 28 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_CLASSIFIER ) )
251 : {
252 14 : (*out_type) = DATA_TABLE_CLASSIFIER;
253 : }
254 : /*
255 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_FEATURE ) )
256 : {
257 : (*out_type) = DATA_TABLE_FEATURE;
258 : }
259 : */
260 14 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP ) )
261 : {
262 13 : (*out_type) = DATA_TABLE_RELATIONSHIP;
263 : }
264 : else
265 : {
266 1 : U8_LOG_ERROR_INT( "unexpected token at line",
267 : json_token_reader_get_input_line( &((*this_).tokenizer) )
268 : );
269 1 : result = U8_ERROR_PARSER_STRUCTURE;
270 : }
271 : }
272 37 : if ( U8_ERROR_NONE == result )
273 : {
274 36 : result = json_token_reader_expect_name_separator ( &((*this_).tokenizer) );
275 : }
276 : }
277 : }
278 :
279 37 : U8_TRACE_END_ERR( result );
280 37 : return result;
281 : }
282 :
283 31 : u8_error_t json_element_reader_expect_end_type_of_element ( json_element_reader_t *this_ )
284 : {
285 31 : U8_TRACE_BEGIN();
286 31 : u8_error_t result = U8_ERROR_NONE;
287 : bool condition;
288 :
289 31 : result = json_token_reader_check_end_object ( &((*this_).tokenizer), &condition );
290 31 : if ( ! condition )
291 : {
292 0 : U8_LOG_ERROR_INT( "unexpected object contents at line",
293 : json_token_reader_get_input_line( &((*this_).tokenizer) )
294 : );
295 0 : result |= U8_ERROR_PARSER_STRUCTURE;
296 : }
297 :
298 31 : U8_TRACE_END_ERR( result );
299 31 : return result;
300 : }
301 :
302 14 : u8_error_t json_element_reader_get_next_classifier ( json_element_reader_t *this_,
303 : data_classifier_t *out_object,
304 : bool* out_has_features_array )
305 : {
306 14 : U8_TRACE_BEGIN();
307 14 : assert ( NULL != out_object );
308 14 : assert ( NULL != out_has_features_array );
309 14 : u8_error_t result = U8_ERROR_NONE;
310 :
311 : char member_name_buf[24];
312 14 : utf8stringbuf_t member_name = UTF8STRINGBUF( member_name_buf );
313 :
314 14 : data_classifier_init_empty( out_object );
315 :
316 : /* header */
317 :
318 14 : result = json_token_reader_expect_begin_object ( &((*this_).tokenizer) );
319 :
320 : /* members */
321 :
322 14 : bool first_member_passed = false;
323 14 : bool object_end = false;
324 14 : bool break_at_features = false;
325 156 : while (( ! object_end )&&( ! break_at_features )&&( U8_ERROR_NONE == result ))
326 : {
327 142 : result = json_token_reader_check_end_object ( &((*this_).tokenizer), &object_end );
328 142 : if ( U8_ERROR_NONE == result )
329 : {
330 142 : if ( ! object_end )
331 : {
332 142 : if ( first_member_passed )
333 : {
334 128 : result = json_token_reader_expect_value_separator ( &((*this_).tokenizer) );
335 : }
336 : else
337 : {
338 14 : first_member_passed = true;
339 : }
340 142 : if ( U8_ERROR_NONE == result )
341 : {
342 142 : result = json_token_reader_read_member_name ( &((*this_).tokenizer), member_name );
343 : }
344 142 : if ( U8_ERROR_NONE == result )
345 : {
346 142 : result = json_token_reader_expect_name_separator ( &((*this_).tokenizer) );
347 : }
348 142 : if ( U8_ERROR_NONE == result )
349 : {
350 142 : if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_CLASSIFIER_ID ) )
351 : {
352 : int64_t parsed_integer;
353 14 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
354 14 : data_classifier_set_row_id ( out_object, parsed_integer );
355 : }
356 128 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_CLASSIFIER_MAIN_TYPE )
357 114 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_TYPE_ID ) )
358 14 : {
359 : int64_t parsed_integer;
360 14 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
361 14 : data_classifier_set_main_type ( out_object, parsed_integer );
362 : }
363 114 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_TYPE_NAME ) )
364 : {
365 7 : result = json_element_reader_skip_next_string( this_ );
366 : }
367 107 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_CLASSIFIER_X_ORDER ) )
368 : {
369 : int64_t parsed_integer;
370 14 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
371 14 : data_classifier_set_x_order ( out_object, parsed_integer );
372 : }
373 93 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_CLASSIFIER_Y_ORDER ) )
374 : {
375 : int64_t parsed_integer;
376 14 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
377 14 : data_classifier_set_y_order ( out_object, parsed_integer );
378 : }
379 79 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_CLASSIFIER_LIST_ORDER )
380 65 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_ORDER ) )
381 14 : {
382 : int64_t parsed_integer;
383 14 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
384 14 : data_classifier_set_list_order ( out_object, parsed_integer );
385 : }
386 65 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_CLASSIFIER_STEREOTYPE ) )
387 : {
388 14 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
389 14 : data_classifier_set_stereotype( out_object,
390 14 : utf8stringbuf_get_string( &((*this_).temp_string) )
391 : );
392 : }
393 51 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_CLASSIFIER_NAME ) )
394 : {
395 14 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
396 14 : data_classifier_set_name( out_object,
397 14 : utf8stringbuf_get_string( &((*this_).temp_string) )
398 : );
399 : }
400 37 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_CLASSIFIER_DESCRIPTION ) )
401 : {
402 14 : result = json_element_reader_private_read_string_array( this_, (*this_).temp_string );
403 14 : data_classifier_set_description( out_object,
404 14 : utf8stringbuf_get_string( &((*this_).temp_string) )
405 : );
406 : }
407 23 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_UUID ) )
408 : {
409 9 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
410 9 : result |= data_classifier_set_uuid( out_object,
411 9 : utf8stringbuf_get_string( &((*this_).temp_string) )
412 : );
413 : }
414 14 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_CLASSIFIER_FEATURES ) )
415 : {
416 14 : break_at_features = true; /* end the loop */
417 : }
418 : else
419 : {
420 0 : U8_LOG_ERROR_INT( "unexpected member name at line",
421 : json_token_reader_get_input_line( &((*this_).tokenizer) )
422 : );
423 0 : result = U8_ERROR_PARSER_STRUCTURE;
424 : }
425 : }
426 : }
427 : }
428 : else
429 : {
430 0 : U8_LOG_ERROR_INT( "unexpected character at line",
431 : json_token_reader_get_input_line( &((*this_).tokenizer) )
432 : );
433 0 : result = U8_ERROR_PARSER_STRUCTURE;
434 0 : object_end = true;
435 : }
436 : }
437 :
438 : /* footer */
439 :
440 14 : if ( U8_ERROR_NONE == result )
441 : {
442 14 : data_classifier_trace( out_object );
443 : }
444 :
445 14 : *out_has_features_array = break_at_features;
446 14 : U8_TRACE_END_ERR( result );
447 14 : return result;
448 : }
449 :
450 20 : u8_error_t json_element_reader_end_unfinished_object ( json_element_reader_t *this_ )
451 : {
452 20 : U8_TRACE_BEGIN();
453 20 : u8_error_t result = U8_ERROR_NONE;
454 :
455 20 : bool object_end = false;
456 20 : result = json_token_reader_check_end_object ( &((*this_).tokenizer), &object_end );
457 20 : if ( U8_ERROR_NONE == result )
458 : {
459 20 : if (! object_end)
460 : {
461 0 : result = U8_ERROR_PARSER_STRUCTURE;
462 : }
463 : }
464 :
465 20 : U8_TRACE_END_ERR( result );
466 20 : return result;
467 : }
468 :
469 9 : u8_error_t json_element_reader_get_next_diagram ( json_element_reader_t *this_,
470 : data_diagram_t *out_object,
471 : utf8stringbuf_t out_parent_uuid,
472 : bool* out_has_diagramelements_array )
473 : {
474 9 : U8_TRACE_BEGIN();
475 9 : assert ( NULL != out_object );
476 9 : assert ( NULL != out_has_diagramelements_array );
477 9 : u8_error_t result = U8_ERROR_NONE;
478 :
479 : char member_name_buf[24];
480 9 : utf8stringbuf_t member_name = UTF8STRINGBUF( member_name_buf );
481 :
482 9 : data_diagram_init_empty( out_object );
483 9 : utf8stringbuf_clear( &out_parent_uuid );
484 :
485 : /* header */
486 :
487 9 : result = json_token_reader_expect_begin_object ( &((*this_).tokenizer) );
488 :
489 : /* members */
490 :
491 9 : bool first_member_passed = false;
492 9 : bool object_end = false;
493 9 : bool break_at_subelements = false;
494 92 : while (( ! object_end )&&( ! break_at_subelements )&&( U8_ERROR_NONE == result ))
495 : {
496 83 : result = json_token_reader_check_end_object ( &((*this_).tokenizer), &object_end );
497 83 : if ( U8_ERROR_NONE == result )
498 : {
499 83 : if ( ! object_end )
500 : {
501 82 : if ( first_member_passed )
502 : {
503 74 : result = json_token_reader_expect_value_separator ( &((*this_).tokenizer) );
504 : }
505 : else
506 : {
507 8 : first_member_passed = true;
508 : }
509 82 : if ( U8_ERROR_NONE == result )
510 : {
511 82 : result = json_token_reader_read_member_name ( &((*this_).tokenizer), member_name );
512 : }
513 82 : if ( U8_ERROR_NONE == result )
514 : {
515 82 : result = json_token_reader_expect_name_separator ( &((*this_).tokenizer) );
516 : }
517 82 : if ( U8_ERROR_NONE == result )
518 : {
519 82 : if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAM_ID ) )
520 : {
521 : int64_t parsed_integer;
522 8 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
523 8 : data_diagram_set_row_id ( out_object, parsed_integer );
524 : }
525 74 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAM_PARENT_ID ) )
526 : {
527 : int64_t ignored_integer;
528 0 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &ignored_integer );
529 : (void) ignored_integer;
530 : }
531 74 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAM_PARENT_NAME ) )
532 : {
533 7 : result = json_element_reader_skip_next_string( this_ );
534 : }
535 67 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAM_DIAGRAM_TYPE )
536 59 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_TYPE_ID ) )
537 8 : {
538 : int64_t parsed_integer;
539 8 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
540 8 : data_diagram_set_diagram_type ( out_object, parsed_integer );
541 : }
542 59 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_TYPE_NAME ) )
543 : {
544 7 : result = json_element_reader_skip_next_string( this_ );
545 : }
546 52 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAM_LIST_ORDER )
547 44 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_ORDER ) )
548 8 : {
549 : int64_t parsed_integer;
550 8 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
551 8 : data_diagram_set_list_order ( out_object, parsed_integer );
552 : }
553 44 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAM_DESCRIPTION ) )
554 : {
555 8 : result = json_element_reader_private_read_string_array( this_, (*this_).temp_string );
556 8 : data_diagram_set_description( out_object,
557 8 : utf8stringbuf_get_string( &((*this_).temp_string) )
558 : );
559 : }
560 36 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAM_NAME ) )
561 : {
562 8 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
563 8 : result |= data_diagram_set_name( out_object,
564 8 : utf8stringbuf_get_string( &((*this_).temp_string) )
565 : );
566 : }
567 28 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAM_STEREOTYPE ) )
568 : {
569 : /* new in 1.43.0: stereotype; imported since 1.47.0 */
570 0 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
571 0 : result |= data_diagram_set_stereotype( out_object,
572 0 : utf8stringbuf_get_string( &((*this_).temp_string) )
573 : );
574 : }
575 28 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAM_DISPLAY_FLAGS ) )
576 : {
577 : int64_t parsed_integer;
578 7 : result = json_token_reader_read_int_value( &((*this_).tokenizer), &parsed_integer );
579 7 : data_diagram_set_display_flags ( out_object, parsed_integer );
580 : }
581 21 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAM_DISPLAY_FLAG_NAMES ) )
582 : {
583 7 : result = json_element_reader_skip_next_string( this_ );
584 : }
585 14 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAM_PARENT ) )
586 : {
587 0 : result = json_token_reader_read_string_value( &((*this_).tokenizer), out_parent_uuid );
588 : }
589 14 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_UUID ) )
590 : {
591 7 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
592 7 : result |= data_diagram_set_uuid( out_object,
593 7 : utf8stringbuf_get_string( &((*this_).temp_string) )
594 : );
595 : }
596 7 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAM_ELEMENTS )
597 0 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAM_ELEMENT_LIST ) )
598 : {
599 7 : break_at_subelements = true; /* end the loop */
600 : }
601 : else
602 : {
603 0 : U8_LOG_ERROR_INT( "unexpected member name at line",
604 : json_token_reader_get_input_line( &((*this_).tokenizer) )
605 : );
606 0 : result = U8_ERROR_PARSER_STRUCTURE;
607 : }
608 : }
609 : }
610 : }
611 : else
612 : {
613 0 : U8_LOG_ERROR_INT( "unexpected character at line",
614 : json_token_reader_get_input_line( &((*this_).tokenizer) )
615 : );
616 0 : result = U8_ERROR_PARSER_STRUCTURE;
617 0 : object_end = true;
618 : }
619 : }
620 :
621 : /* footer */
622 :
623 9 : if ( U8_ERROR_NONE == result )
624 : {
625 8 : data_diagram_trace( out_object );
626 : }
627 :
628 9 : *out_has_diagramelements_array = break_at_subelements;
629 9 : U8_TRACE_END_ERR( result );
630 9 : return result;
631 : }
632 :
633 13 : u8_error_t json_element_reader_get_next_relationship ( json_element_reader_t *this_,
634 : data_relationship_t *out_object,
635 : utf8stringbuf_t out_from_node_uuid,
636 : utf8stringbuf_t out_to_node_uuid
637 : )
638 : {
639 13 : U8_TRACE_BEGIN();
640 13 : assert( NULL != out_object );
641 13 : u8_error_t result = U8_ERROR_NONE;
642 :
643 : char member_name_buf[24];
644 13 : utf8stringbuf_t member_name = UTF8STRINGBUF( member_name_buf );
645 :
646 13 : data_relationship_init_empty( out_object );
647 13 : utf8stringbuf_clear( &out_from_node_uuid );
648 13 : utf8stringbuf_clear( &out_to_node_uuid );
649 :
650 : /* header */
651 :
652 13 : result = json_token_reader_expect_begin_object ( &((*this_).tokenizer) );
653 :
654 : /* members */
655 :
656 13 : bool first_member_passed = false;
657 13 : bool object_end = false;
658 236 : while (( ! object_end )&&( U8_ERROR_NONE == result ))
659 : {
660 223 : result = json_token_reader_check_end_object ( &((*this_).tokenizer), &object_end );
661 223 : if ( U8_ERROR_NONE == result )
662 : {
663 223 : if ( ! object_end )
664 : {
665 210 : if ( first_member_passed )
666 : {
667 197 : result = json_token_reader_expect_value_separator ( &((*this_).tokenizer) );
668 : }
669 : else
670 : {
671 13 : first_member_passed = true;
672 : }
673 210 : if ( U8_ERROR_NONE == result )
674 : {
675 210 : result = json_token_reader_read_member_name ( &((*this_).tokenizer), member_name );
676 : }
677 210 : if ( U8_ERROR_NONE == result )
678 : {
679 210 : result = json_token_reader_expect_name_separator ( &((*this_).tokenizer) );
680 : }
681 210 : if ( U8_ERROR_NONE == result )
682 : {
683 210 : if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_ID ) )
684 : {
685 : int64_t parsed_integer;
686 13 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
687 13 : data_relationship_set_row_id ( out_object, parsed_integer );
688 : }
689 197 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_MAIN_TYPE )
690 184 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_TYPE_ID ) )
691 13 : {
692 : int64_t parsed_integer;
693 13 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
694 13 : data_relationship_set_main_type ( out_object, parsed_integer );
695 : }
696 184 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_TYPE_NAME ) )
697 : {
698 7 : result = json_element_reader_skip_next_string( this_ );
699 : }
700 177 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_STEREOTYPE ) )
701 : {
702 : /* new in 1.43.0: stereotype; imported since 1.47.0 */
703 0 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
704 0 : data_relationship_set_stereotype( out_object,
705 0 : utf8stringbuf_get_string( &((*this_).temp_string) )
706 : );
707 : }
708 177 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_LIST_ORDER )
709 164 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_ORDER ) )
710 13 : {
711 : int64_t parsed_integer;
712 13 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
713 13 : data_relationship_set_list_order ( out_object, parsed_integer );
714 : }
715 164 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_DESCRIPTION ) )
716 : {
717 13 : result = json_element_reader_private_read_string_array( this_, (*this_).temp_string );
718 13 : data_relationship_set_description( out_object,
719 13 : utf8stringbuf_get_string( &((*this_).temp_string) )
720 : );
721 : }
722 151 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_NAME ) )
723 : {
724 13 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
725 13 : data_relationship_set_name( out_object,
726 13 : utf8stringbuf_get_string( &((*this_).temp_string) )
727 : );
728 : }
729 138 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_FROM_CLASSIFIER_ID ) )
730 : {
731 : int64_t parsed_integer;
732 13 : result = json_token_reader_read_int_value( &((*this_).tokenizer), &parsed_integer );
733 13 : data_relationship_set_from_classifier_row_id ( out_object, parsed_integer );
734 : }
735 125 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_FROM_CLASSIFIER_NAME )
736 112 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_FROM_NODE_NAME ) )
737 : {
738 13 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
739 13 : U8_TRACE_INFO_STR( "from-classifier name:", utf8stringbuf_get_string( &((*this_).temp_string) ) );
740 : }
741 112 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_FROM_FEATURE_ID ) )
742 : {
743 : int64_t parsed_integer;
744 13 : result = json_token_reader_read_int_value( &((*this_).tokenizer), &parsed_integer );
745 13 : data_relationship_set_from_feature_row_id ( out_object, parsed_integer );
746 : }
747 99 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_FROM_FEATURE_KEY )
748 86 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_FROM_PORT_NAME ) )
749 : {
750 13 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
751 13 : U8_TRACE_INFO_STR( "from-feature key:", utf8stringbuf_get_string( &((*this_).temp_string) ) );
752 : }
753 86 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_TO_CLASSIFIER_ID ) )
754 : {
755 : int64_t parsed_integer;
756 13 : result = json_token_reader_read_int_value( &((*this_).tokenizer), &parsed_integer );
757 13 : data_relationship_set_to_classifier_row_id ( out_object, parsed_integer );
758 : }
759 73 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_TO_CLASSIFIER_NAME )
760 60 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_TO_NODE_NAME ) )
761 : {
762 13 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
763 13 : U8_TRACE_INFO_STR( "to-classifier name:", utf8stringbuf_get_string( &((*this_).temp_string) ) );
764 : }
765 60 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_TO_FEATURE_ID ) )
766 : {
767 : int64_t parsed_integer;
768 13 : result = json_token_reader_read_int_value( &((*this_).tokenizer), &parsed_integer );
769 13 : data_relationship_set_to_feature_row_id ( out_object, parsed_integer );
770 : }
771 47 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_TO_FEATURE_KEY )
772 34 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_TO_PORT_NAME ) )
773 : {
774 :
775 13 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
776 13 : U8_TRACE_INFO_STR( "to-feature key:", utf8stringbuf_get_string( &((*this_).temp_string) ) );
777 : }
778 34 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_FROM_NODE )
779 21 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_FROM_NODE_UUID ) )
780 : {
781 13 : result = json_token_reader_read_string_value( &((*this_).tokenizer), out_from_node_uuid );
782 : }
783 21 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_TO_NODE )
784 8 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_TO_NODE_UUID ) )
785 : {
786 13 : result = json_token_reader_read_string_value( &((*this_).tokenizer), out_to_node_uuid );
787 : }
788 8 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_UUID ) )
789 : {
790 8 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
791 8 : result |= data_relationship_set_uuid( out_object,
792 8 : utf8stringbuf_get_string( &((*this_).temp_string) )
793 : );
794 : }
795 : else
796 : {
797 0 : U8_LOG_ERROR_INT( "unexpected member name at line",
798 : json_token_reader_get_input_line( &((*this_).tokenizer) )
799 : );
800 0 : result = U8_ERROR_PARSER_STRUCTURE;
801 : }
802 : }
803 : }
804 : }
805 : else
806 : {
807 0 : U8_LOG_ERROR_INT( "unexpected character at line",
808 : json_token_reader_get_input_line( &((*this_).tokenizer) )
809 : );
810 0 : result = U8_ERROR_PARSER_STRUCTURE;
811 0 : object_end = true;
812 : }
813 : }
814 :
815 : /* footer */
816 :
817 13 : if ( U8_ERROR_NONE == result )
818 : {
819 13 : data_relationship_trace( out_object );
820 : }
821 :
822 13 : U8_TRACE_END_ERR( result );
823 13 : return result;
824 : }
825 :
826 20 : u8_error_t json_element_reader_skip_next_object ( json_element_reader_t *this_ )
827 : {
828 20 : U8_TRACE_BEGIN();
829 20 : u8_error_t result = U8_ERROR_NONE;
830 :
831 : char member_name_buf[24];
832 20 : utf8stringbuf_t member_name = UTF8STRINGBUF( member_name_buf );
833 :
834 : /* header */
835 :
836 20 : result = json_token_reader_expect_begin_object ( &((*this_).tokenizer) );
837 :
838 : /* members */
839 :
840 20 : bool first_member_passed = false;
841 20 : bool object_end = false;
842 61 : while (( ! object_end )&&( U8_ERROR_NONE == result ))
843 : {
844 41 : result = json_token_reader_check_end_object ( &((*this_).tokenizer), &object_end );
845 41 : if ( U8_ERROR_NONE == result )
846 : {
847 41 : if ( ! object_end )
848 : {
849 21 : if ( first_member_passed )
850 : {
851 18 : result = json_token_reader_expect_value_separator ( &((*this_).tokenizer) );
852 : }
853 : else
854 : {
855 3 : first_member_passed = true;
856 : }
857 21 : if ( U8_ERROR_NONE == result )
858 : {
859 21 : result = json_token_reader_read_member_name ( &((*this_).tokenizer), member_name );
860 : }
861 21 : if ( U8_ERROR_NONE == result )
862 : {
863 21 : result = json_token_reader_expect_name_separator ( &((*this_).tokenizer) );
864 : }
865 : json_value_type_t v_type;
866 21 : if ( U8_ERROR_NONE == result )
867 : {
868 21 : result = json_token_reader_get_value_type ( &((*this_).tokenizer), &v_type );
869 : }
870 21 : if ( U8_ERROR_NONE == result )
871 : {
872 21 : switch ( v_type )
873 : {
874 0 : case JSON_VALUE_TYPE_OBJECT:
875 : {
876 0 : result = U8_ERROR_PARSER_STRUCTURE; /* this function does not expect objects in objects */
877 : }
878 0 : break;
879 :
880 0 : case JSON_VALUE_TYPE_ARRAY:
881 : {
882 0 : result = U8_ERROR_PARSER_STRUCTURE; /* this function does not expect arrays in objects */
883 : }
884 0 : break;
885 :
886 6 : case JSON_VALUE_TYPE_NUMBER:
887 : {
888 : double parsed_number;
889 6 : /* result = */ json_token_reader_read_number_value ( &((*this_).tokenizer), &parsed_number );
890 : /* ignore the U8_ERROR_NOT_YET_IMPLEMENTED here... */
891 : }
892 6 : break;
893 :
894 0 : case JSON_VALUE_TYPE_INTEGER:
895 : {
896 : int64_t parsed_integer;
897 0 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
898 : }
899 0 : break;
900 :
901 15 : case JSON_VALUE_TYPE_STRING:
902 : {
903 15 : result = json_element_reader_skip_next_string( this_ );
904 : }
905 15 : break;
906 :
907 0 : case JSON_VALUE_TYPE_BOOLEAN:
908 : {
909 : bool parsed_bool;
910 0 : result = json_token_reader_read_boolean_value ( &((*this_).tokenizer), &parsed_bool );
911 : }
912 0 : break;
913 :
914 0 : case JSON_VALUE_TYPE_NULL:
915 : {
916 0 : result = json_token_reader_expect_null_value ( &((*this_).tokenizer) );
917 : }
918 0 : break;
919 :
920 0 : case JSON_VALUE_TYPE_UNDEF:
921 : default:
922 : {
923 0 : U8_LOG_ERROR_INT( "unexpected member name at line",
924 : json_token_reader_get_input_line( &((*this_).tokenizer) )
925 : );
926 0 : result = U8_ERROR_PARSER_STRUCTURE; /* this function does not expect objects in objects */
927 : }
928 0 : break;
929 : }
930 : }
931 : }
932 : }
933 : else
934 : {
935 0 : U8_LOG_ERROR_INT( "unexpected character at line",
936 : json_token_reader_get_input_line( &((*this_).tokenizer) )
937 : );
938 0 : result = U8_ERROR_PARSER_STRUCTURE;
939 0 : object_end = true;
940 : }
941 : }
942 :
943 : /* footer */
944 :
945 20 : U8_TRACE_END_ERR( result );
946 20 : return result;
947 : }
948 :
949 78 : u8_error_t json_element_reader_skip_next_string ( json_element_reader_t *this_ )
950 : {
951 78 : U8_TRACE_BEGIN();
952 78 : u8_error_t result = U8_ERROR_NONE;
953 : char dummy_str[4];
954 78 : utf8stringbuf_t dummy_strbuf = UTF8STRINGBUF ( dummy_str );
955 :
956 78 : result = json_token_reader_read_string_value ( &((*this_).tokenizer), dummy_strbuf );
957 78 : if ( result == U8_ERROR_STRING_BUFFER_EXCEEDED )
958 : {
959 : /* ignore this. The result string is not needed therefore dummy_str may be too small */
960 50 : result = U8_ERROR_NONE;
961 : }
962 :
963 78 : U8_TRACE_END_ERR( result );
964 78 : return result;
965 : }
966 :
967 21 : uint32_t json_element_reader_get_read_line ( json_element_reader_t *this_ )
968 : {
969 21 : U8_TRACE_BEGIN();
970 :
971 21 : const uint32_t read_line = json_token_reader_get_input_line( &((*this_).tokenizer) );
972 21 : U8_TRACE_INFO_INT( "line", read_line );
973 :
974 21 : U8_TRACE_END();
975 21 : return read_line;
976 : }
977 :
978 22 : u8_error_t json_element_reader_get_next_feature ( json_element_reader_t *this_, data_feature_t *out_object )
979 : {
980 22 : U8_TRACE_BEGIN();
981 22 : assert ( NULL != out_object );
982 :
983 22 : u8_error_t result = U8_ERROR_NONE;
984 :
985 : char member_name_buf[24];
986 22 : utf8stringbuf_t member_name = UTF8STRINGBUF( member_name_buf );
987 :
988 22 : data_feature_init_empty( out_object );
989 :
990 : /* header */
991 :
992 22 : result = json_token_reader_expect_begin_object ( &((*this_).tokenizer) );
993 :
994 : /* members */
995 :
996 22 : bool first_member_passed = false;
997 22 : bool object_end = false;
998 194 : while (( ! object_end )&&( U8_ERROR_NONE == result ))
999 : {
1000 172 : result = json_token_reader_check_end_object ( &((*this_).tokenizer), &object_end );
1001 172 : if ( U8_ERROR_NONE == result )
1002 : {
1003 172 : if ( ! object_end )
1004 : {
1005 150 : if ( first_member_passed )
1006 : {
1007 128 : result = json_token_reader_expect_value_separator ( &((*this_).tokenizer) );
1008 : }
1009 : else
1010 : {
1011 22 : first_member_passed = true;
1012 : }
1013 150 : if ( U8_ERROR_NONE == result )
1014 : {
1015 150 : result = json_token_reader_read_member_name( &((*this_).tokenizer), member_name );
1016 : }
1017 150 : if ( U8_ERROR_NONE == result )
1018 : {
1019 150 : result = json_token_reader_expect_name_separator( &((*this_).tokenizer) );
1020 : }
1021 150 : if ( U8_ERROR_NONE == result )
1022 : {
1023 150 : if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_FEATURE_ID ) )
1024 : {
1025 : int64_t parsed_integer;
1026 22 : result = json_token_reader_read_int_value( &((*this_).tokenizer), &parsed_integer );
1027 22 : data_feature_set_row_id ( out_object, parsed_integer );
1028 : }
1029 128 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_FEATURE_MAIN_TYPE )
1030 106 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_TYPE_ID ) )
1031 22 : {
1032 : int64_t parsed_integer;
1033 22 : result = json_token_reader_read_int_value( &((*this_).tokenizer), &parsed_integer );
1034 22 : data_feature_set_main_type( out_object, parsed_integer );
1035 : }
1036 106 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_TYPE_NAME ) )
1037 : {
1038 7 : result = json_element_reader_skip_next_string( this_ );
1039 : }
1040 99 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_FEATURE_LIST_ORDER )
1041 77 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_ORDER ) )
1042 22 : {
1043 : int64_t parsed_integer;
1044 22 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
1045 22 : data_feature_set_list_order ( out_object, parsed_integer );
1046 : }
1047 77 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_FEATURE_DESCRIPTION ) )
1048 : {
1049 22 : result = json_element_reader_private_read_string_array( this_, (*this_).temp_string );
1050 22 : data_feature_set_description( out_object,
1051 22 : utf8stringbuf_get_string( &((*this_).temp_string) )
1052 : );
1053 : }
1054 55 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_FEATURE_KEY ) )
1055 : {
1056 22 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
1057 22 : data_feature_set_key( out_object,
1058 22 : utf8stringbuf_get_string( &((*this_).temp_string) )
1059 : );
1060 : }
1061 33 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_FEATURE_VALUE ) )
1062 : {
1063 22 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
1064 22 : data_feature_set_value( out_object,
1065 22 : utf8stringbuf_get_string( &((*this_).temp_string) )
1066 : );
1067 : }
1068 11 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_UUID ) )
1069 : {
1070 11 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
1071 11 : result |= data_feature_set_uuid( out_object,
1072 11 : utf8stringbuf_get_string( &((*this_).temp_string) )
1073 : );
1074 : }
1075 : else
1076 : {
1077 0 : U8_LOG_ERROR_INT( "unexpected member name at line",
1078 : json_token_reader_get_input_line( &((*this_).tokenizer) )
1079 : );
1080 0 : result = U8_ERROR_PARSER_STRUCTURE;
1081 : }
1082 : }
1083 : }
1084 : }
1085 : else
1086 : {
1087 0 : U8_LOG_ERROR_INT( "unexpected character at line",
1088 : json_token_reader_get_input_line( &((*this_).tokenizer) )
1089 : );
1090 0 : result = U8_ERROR_PARSER_STRUCTURE;
1091 0 : object_end = true;
1092 : }
1093 : }
1094 :
1095 : /* footer */
1096 :
1097 22 : if ( U8_ERROR_NONE == result )
1098 : {
1099 22 : data_feature_trace( out_object );
1100 : }
1101 :
1102 22 : U8_TRACE_END_ERR( result );
1103 22 : return result;
1104 : }
1105 :
1106 7 : u8_error_t json_element_reader_get_next_diagramelement( json_element_reader_t *this_,
1107 : data_diagramelement_t *out_object,
1108 : utf8stringbuf_t out_node_uuid )
1109 : {
1110 7 : U8_TRACE_BEGIN();
1111 7 : assert ( NULL != out_object );
1112 :
1113 7 : u8_error_t result = U8_ERROR_NONE;
1114 :
1115 : char member_name_buf[24];
1116 7 : utf8stringbuf_t member_name = UTF8STRINGBUF( member_name_buf );
1117 :
1118 7 : data_diagramelement_init_empty( out_object );
1119 :
1120 : /* header */
1121 :
1122 7 : result = json_token_reader_expect_begin_object ( &((*this_).tokenizer) );
1123 :
1124 : /* members */
1125 :
1126 7 : bool first_member_passed = false;
1127 7 : bool object_end = false;
1128 77 : while (( ! object_end )&&( U8_ERROR_NONE == result ))
1129 : {
1130 70 : result = json_token_reader_check_end_object ( &((*this_).tokenizer), &object_end );
1131 70 : if ( U8_ERROR_NONE == result )
1132 : {
1133 70 : if ( ! object_end )
1134 : {
1135 63 : if ( first_member_passed )
1136 : {
1137 56 : result = json_token_reader_expect_value_separator ( &((*this_).tokenizer) );
1138 : }
1139 : else
1140 : {
1141 7 : first_member_passed = true;
1142 : }
1143 63 : if ( U8_ERROR_NONE == result )
1144 : {
1145 63 : result = json_token_reader_read_member_name( &((*this_).tokenizer), member_name );
1146 : }
1147 63 : if ( U8_ERROR_NONE == result )
1148 : {
1149 63 : result = json_token_reader_expect_name_separator( &((*this_).tokenizer) );
1150 : }
1151 63 : if ( U8_ERROR_NONE == result )
1152 : {
1153 63 : if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAMELEMENT_ID ) )
1154 : {
1155 : int64_t parsed_integer;
1156 7 : result = json_token_reader_read_int_value( &((*this_).tokenizer), &parsed_integer );
1157 7 : data_diagramelement_set_row_id ( out_object, parsed_integer );
1158 : }
1159 56 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAMELEMENT_DIAGRAM_ID ) )
1160 : {
1161 : int64_t parsed_integer;
1162 0 : result = json_token_reader_read_int_value( &((*this_).tokenizer), &parsed_integer );
1163 0 : data_diagramelement_set_diagram_row_id( out_object, parsed_integer );
1164 : }
1165 56 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAMELEMENT_CLASSIFIER_ID ) )
1166 : {
1167 : int64_t parsed_integer;
1168 7 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
1169 7 : data_diagramelement_set_classifier_row_id ( out_object, parsed_integer );
1170 : }
1171 49 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAMELEMENT_CLASSIFIER_NAME )
1172 42 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAMELEMENT_NODE_NAME ) )
1173 : {
1174 7 : result = json_element_reader_skip_next_string( this_ );
1175 : }
1176 42 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAMELEMENT_FOCUSED_FEATURE_ID ) )
1177 : {
1178 : int64_t parsed_integer;
1179 7 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
1180 7 : data_diagramelement_set_focused_feature_row_id ( out_object, parsed_integer );
1181 : }
1182 35 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAMELEMENT_FOCUSED_FEATURE_NAME ) )
1183 : {
1184 7 : result = json_element_reader_skip_next_string( this_ );
1185 : }
1186 28 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAMELEMENT_DISPLAY_FLAGS ) )
1187 : {
1188 : int64_t parsed_integer;
1189 7 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
1190 7 : data_diagramelement_set_display_flags ( out_object, parsed_integer );
1191 : }
1192 21 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAMELEMENT_DISPLAY_FLAG_NAMES ) )
1193 : {
1194 7 : result = json_element_reader_skip_next_string( this_ );
1195 : }
1196 14 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAMELEMENT_NODE ) )
1197 : {
1198 7 : result = json_token_reader_read_string_value( &((*this_).tokenizer), out_node_uuid );
1199 : }
1200 7 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_UUID ) )
1201 : {
1202 7 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
1203 7 : result |= data_diagramelement_set_uuid( out_object,
1204 7 : utf8stringbuf_get_string( &((*this_).temp_string) )
1205 : );
1206 : }
1207 : else
1208 : {
1209 0 : U8_LOG_ERROR_INT( "unexpected member name at line",
1210 : json_token_reader_get_input_line( &((*this_).tokenizer) )
1211 : );
1212 0 : result = U8_ERROR_PARSER_STRUCTURE;
1213 : }
1214 : }
1215 : }
1216 : }
1217 : else
1218 : {
1219 0 : U8_LOG_ERROR_INT( "unexpected character at line",
1220 : json_token_reader_get_input_line( &((*this_).tokenizer) )
1221 : );
1222 0 : result = U8_ERROR_PARSER_STRUCTURE;
1223 0 : object_end = true;
1224 : }
1225 : }
1226 :
1227 : /* footer */
1228 :
1229 7 : if ( U8_ERROR_NONE == result )
1230 : {
1231 7 : data_diagramelement_trace( out_object );
1232 : }
1233 :
1234 7 : U8_TRACE_END_ERR( result );
1235 7 : return result;
1236 : }
1237 :
1238 57 : u8_error_t json_element_reader_private_read_string_array ( json_element_reader_t *this_,
1239 : utf8stringbuf_t out_joined_string )
1240 : {
1241 57 : U8_TRACE_BEGIN();
1242 57 : u8_error_t result = U8_ERROR_NONE;
1243 :
1244 57 : utf8stringbuf_clear( &out_joined_string );
1245 :
1246 57 : result = json_token_reader_expect_begin_array( &((*this_).tokenizer) );
1247 :
1248 57 : bool end_array = false;
1249 57 : bool first_element_passed = false;
1250 173 : while (( ! end_array )&&( U8_ERROR_NONE == result ))
1251 : {
1252 116 : result = json_token_reader_check_end_array( &((*this_).tokenizer), &end_array );
1253 116 : if ( U8_ERROR_NONE == result )
1254 : {
1255 116 : if ( ! end_array )
1256 : {
1257 59 : if ( first_element_passed )
1258 : {
1259 14 : result = json_token_reader_expect_value_separator ( &((*this_).tokenizer) );
1260 : }
1261 : else
1262 : {
1263 45 : first_element_passed = true;
1264 : }
1265 59 : utf8stringbuf_t unused_remaining = utf8stringbuf_get_end( &out_joined_string );
1266 59 : result |= json_token_reader_read_string_value( &((*this_).tokenizer), unused_remaining );
1267 : }
1268 : }
1269 : else
1270 : {
1271 : /* error, break loop */
1272 0 : U8_LOG_ERROR_INT( "unexpected array contents at line",
1273 : json_token_reader_get_input_line( &((*this_).tokenizer) )
1274 : );
1275 : }
1276 : }
1277 :
1278 57 : U8_TRACE_END_ERR( result );
1279 57 : return result;
1280 : }
1281 :
1282 :
1283 : /*
1284 : Copyright 2016-2026 Andreas Warnke
1285 :
1286 : Licensed under the Apache License, Version 2.0 (the "License");
1287 : you may not use this file except in compliance with the License.
1288 : You may obtain a copy of the License at
1289 :
1290 : http://www.apache.org/licenses/LICENSE-2.0
1291 :
1292 : Unless required by applicable law or agreed to in writing, software
1293 : distributed under the License is distributed on an "AS IS" BASIS,
1294 : WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1295 : See the License for the specific language governing permissions and
1296 : limitations under the License.
1297 : */
|
