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 22 : void json_element_reader_init ( json_element_reader_t *this_, universal_input_stream_t *in_data )
9 : {
10 22 : U8_TRACE_BEGIN();
11 22 : assert( NULL != in_data );
12 :
13 22 : (*this_).temp_string = utf8stringbuf_new( (*this_).temp_string_buffer, sizeof((*this_).temp_string_buffer) );
14 :
15 22 : json_token_reader_init( &((*this_).tokenizer), in_data );
16 :
17 22 : (*this_).top_array_after_first_entry = false;
18 22 : (*this_).sub_array_after_first_entry = false;
19 :
20 22 : U8_TRACE_END();
21 22 : }
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 22 : void json_element_reader_destroy ( json_element_reader_t *this_ )
35 : {
36 22 : U8_TRACE_BEGIN();
37 :
38 22 : json_token_reader_destroy( &((*this_).tokenizer) );
39 :
40 22 : U8_TRACE_END();
41 22 : }
42 :
43 22 : u8_error_t json_element_reader_expect_header ( json_element_reader_t *this_ )
44 : {
45 22 : U8_TRACE_BEGIN();
46 22 : u8_error_t result = U8_ERROR_NONE;
47 22 : char member_name_buf[24] = "";
48 22 : utf8stringbuf_t member_name = UTF8STRINGBUF( member_name_buf );
49 :
50 22 : result = json_token_reader_expect_begin_object ( &((*this_).tokenizer) );
51 :
52 22 : if ( U8_ERROR_NONE == result )
53 : {
54 21 : result = json_token_reader_read_member_name ( &((*this_).tokenizer), member_name );
55 21 : 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 22 : if ( U8_ERROR_NONE == result )
65 : {
66 21 : result = json_token_reader_expect_name_separator( &((*this_).tokenizer) );
67 : }
68 :
69 22 : if ( U8_ERROR_NONE == result )
70 : {
71 21 : result = json_element_reader_skip_next_object( this_ );
72 : }
73 :
74 22 : U8_TRACE_END_ERR( result );
75 22 : return result;
76 : }
77 :
78 58 : u8_error_t json_element_reader_expect_begin_top_array ( json_element_reader_t *this_ )
79 : {
80 58 : U8_TRACE_BEGIN();
81 58 : u8_error_t result = U8_ERROR_NONE;
82 58 : char member_name_buf[24] = "";
83 58 : utf8stringbuf_t member_name = UTF8STRINGBUF( member_name_buf );
84 :
85 58 : result = json_token_reader_expect_value_separator ( &((*this_).tokenizer) );
86 :
87 58 : if ( U8_ERROR_NONE == result )
88 : {
89 58 : result = json_token_reader_read_member_name ( &((*this_).tokenizer), member_name );
90 58 : if (( ! utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_VIEWS ) )
91 37 : && ( ! utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_NODES ) )
92 18 : && ( ! 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 58 : if ( U8_ERROR_NONE == result )
102 : {
103 58 : result = json_token_reader_expect_name_separator( &((*this_).tokenizer) );
104 : }
105 :
106 58 : if ( U8_ERROR_NONE == result )
107 : {
108 58 : result = json_token_reader_expect_begin_array( &((*this_).tokenizer) );
109 : }
110 :
111 58 : U8_TRACE_END_ERR( result );
112 58 : return result;
113 : }
114 :
115 18 : u8_error_t json_element_reader_expect_footer ( json_element_reader_t *this_ )
116 : {
117 18 : U8_TRACE_BEGIN();
118 18 : u8_error_t result = U8_ERROR_NONE;
119 :
120 : bool end_ok;
121 18 : result = json_token_reader_check_end_object ( &((*this_).tokenizer), &end_ok );
122 18 : 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 18 : if ( U8_ERROR_NONE == result )
131 : {
132 18 : result = json_token_reader_expect_eof ( &((*this_).tokenizer) );
133 : }
134 :
135 18 : U8_TRACE_END_ERR( result );
136 18 : return result;
137 : }
138 :
139 103 : u8_error_t json_element_reader_check_end_top_array ( json_element_reader_t *this_, bool* out_end )
140 : {
141 103 : U8_TRACE_BEGIN();
142 103 : assert( NULL != out_end );
143 103 : u8_error_t result = U8_ERROR_NONE;
144 :
145 103 : result = json_token_reader_check_end_array ( &((*this_).tokenizer), out_end );
146 :
147 103 : if (( U8_ERROR_NONE == result ) && ( *out_end ))
148 : {
149 55 : (*this_).top_array_after_first_entry = false;
150 : }
151 :
152 103 : U8_TRACE_END_ERR( result );
153 103 : return result;
154 : }
155 :
156 29 : u8_error_t json_element_reader_expect_begin_sub_array ( json_element_reader_t *this_ )
157 : {
158 29 : U8_TRACE_BEGIN();
159 29 : u8_error_t result = U8_ERROR_NONE;
160 :
161 29 : result = json_token_reader_expect_begin_array( &((*this_).tokenizer) );
162 29 : if ( U8_ERROR_NONE == result )
163 : {
164 29 : (*this_).sub_array_after_first_entry = false;
165 : }
166 :
167 29 : U8_TRACE_END_ERR( result );
168 29 : return result;
169 : }
170 :
171 65 : u8_error_t json_element_reader_check_end_sub_array ( json_element_reader_t *this_, bool* out_end )
172 : {
173 65 : U8_TRACE_BEGIN();
174 65 : assert( NULL != out_end );
175 65 : u8_error_t result = U8_ERROR_NONE;
176 :
177 65 : result = json_token_reader_check_end_array ( &((*this_).tokenizer), out_end );
178 :
179 65 : if ( U8_ERROR_NONE == result )
180 : {
181 65 : if ( *out_end )
182 : {
183 29 : (*this_).sub_array_after_first_entry = false;
184 : }
185 : else
186 : {
187 36 : if ( (*this_).sub_array_after_first_entry )
188 : {
189 11 : result = json_token_reader_expect_value_separator ( &((*this_).tokenizer) );
190 : }
191 : else
192 : {
193 25 : (*this_).sub_array_after_first_entry = true;
194 : }
195 : }
196 : }
197 :
198 65 : U8_TRACE_END_ERR( result );
199 65 : return result;
200 : }
201 :
202 48 : u8_error_t json_element_reader_expect_begin_type_of_element ( json_element_reader_t *this_, data_table_t *out_type )
203 : {
204 48 : U8_TRACE_BEGIN();
205 48 : assert ( NULL != out_type );
206 48 : u8_error_t result = U8_ERROR_NONE;
207 :
208 : bool array_end;
209 : char member_name_buf[24];
210 48 : utf8stringbuf_t member_name = UTF8STRINGBUF( member_name_buf );
211 :
212 48 : result = json_token_reader_check_end_array ( &((*this_).tokenizer), &array_end );
213 :
214 48 : if ( U8_ERROR_NONE == result )
215 : {
216 48 : if ( array_end )
217 : {
218 0 : (*out_type) = DATA_TABLE_VOID;
219 : }
220 : else
221 : {
222 48 : if ( (*this_).top_array_after_first_entry )
223 : {
224 9 : result = json_token_reader_expect_value_separator ( &((*this_).tokenizer) );
225 : }
226 : else
227 : {
228 39 : (*this_).top_array_after_first_entry = true;
229 : }
230 48 : if ( U8_ERROR_NONE == result )
231 : {
232 48 : result = json_token_reader_expect_begin_object ( &((*this_).tokenizer) );
233 : }
234 48 : if ( U8_ERROR_NONE == result )
235 : {
236 48 : result = json_token_reader_read_member_name ( &((*this_).tokenizer), member_name );
237 : }
238 48 : if ( U8_ERROR_NONE == result )
239 : {
240 48 : if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAM ) )
241 : {
242 17 : (*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 31 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_CLASSIFIER ) )
251 : {
252 16 : (*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 15 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP ) )
261 : {
262 14 : (*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 48 : if ( U8_ERROR_NONE == result )
273 : {
274 47 : result = json_token_reader_expect_name_separator ( &((*this_).tokenizer) );
275 : }
276 : }
277 : }
278 :
279 48 : U8_TRACE_END_ERR( result );
280 48 : return result;
281 : }
282 :
283 45 : u8_error_t json_element_reader_expect_end_type_of_element ( json_element_reader_t *this_ )
284 : {
285 45 : U8_TRACE_BEGIN();
286 45 : u8_error_t result = U8_ERROR_NONE;
287 : bool condition;
288 :
289 45 : result = json_token_reader_check_end_object ( &((*this_).tokenizer), &condition );
290 45 : 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 45 : U8_TRACE_END_ERR( result );
299 45 : return result;
300 : }
301 :
302 16 : 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 16 : U8_TRACE_BEGIN();
307 16 : assert ( NULL != out_object );
308 16 : assert ( NULL != out_has_features_array );
309 16 : u8_error_t result = U8_ERROR_NONE;
310 :
311 : char member_name_buf[24];
312 16 : utf8stringbuf_t member_name = UTF8STRINGBUF( member_name_buf );
313 :
314 16 : data_classifier_init_empty( out_object );
315 :
316 : /* header */
317 :
318 16 : result = json_token_reader_expect_begin_object ( &((*this_).tokenizer) );
319 :
320 : /* members */
321 :
322 16 : bool first_member_passed = false;
323 16 : bool object_end = false;
324 16 : bool break_at_features = false;
325 183 : while (( ! object_end )&&( ! break_at_features )&&( U8_ERROR_NONE == result ))
326 : {
327 167 : result = json_token_reader_check_end_object ( &((*this_).tokenizer), &object_end );
328 167 : if ( U8_ERROR_NONE == result )
329 : {
330 167 : if ( ! object_end )
331 : {
332 167 : if ( first_member_passed )
333 : {
334 151 : result = json_token_reader_expect_value_separator ( &((*this_).tokenizer) );
335 : }
336 : else
337 : {
338 16 : first_member_passed = true;
339 : }
340 167 : if ( U8_ERROR_NONE == result )
341 : {
342 167 : result = json_token_reader_read_member_name ( &((*this_).tokenizer), member_name );
343 : }
344 167 : if ( U8_ERROR_NONE == result )
345 : {
346 167 : result = json_token_reader_expect_name_separator ( &((*this_).tokenizer) );
347 : }
348 167 : if ( U8_ERROR_NONE == result )
349 : {
350 167 : if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_CLASSIFIER_ID ) )
351 : {
352 : int64_t parsed_integer;
353 16 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
354 16 : data_classifier_set_row ( out_object, parsed_integer );
355 : }
356 151 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_CLASSIFIER_MAIN_TYPE )
357 135 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_TYPE_ID ) )
358 16 : {
359 : int64_t parsed_integer;
360 16 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
361 16 : data_classifier_set_main_type ( out_object, parsed_integer );
362 : }
363 135 : 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 128 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_CLASSIFIER_X_ORDER ) )
368 : {
369 : int64_t parsed_integer;
370 16 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
371 16 : data_classifier_set_x_order ( out_object, parsed_integer );
372 : }
373 112 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_CLASSIFIER_Y_ORDER ) )
374 : {
375 : int64_t parsed_integer;
376 16 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
377 16 : data_classifier_set_y_order ( out_object, parsed_integer );
378 : }
379 96 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_CLASSIFIER_LIST_ORDER )
380 80 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_ORDER ) )
381 16 : {
382 : int64_t parsed_integer;
383 16 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
384 16 : data_classifier_set_list_order ( out_object, parsed_integer );
385 : }
386 80 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_CLASSIFIER_STEREOTYPE ) )
387 : {
388 16 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
389 16 : data_classifier_set_stereotype( out_object,
390 16 : utf8stringbuf_get_string( &((*this_).temp_string) )
391 : );
392 : }
393 64 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_CLASSIFIER_NAME ) )
394 : {
395 16 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
396 16 : data_classifier_set_name( out_object,
397 16 : utf8stringbuf_get_string( &((*this_).temp_string) )
398 : );
399 : }
400 48 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_CLASSIFIER_DESCRIPTION ) )
401 : {
402 16 : result = json_element_reader_private_read_string_array( this_, (*this_).temp_string );
403 16 : data_classifier_set_description( out_object,
404 16 : utf8stringbuf_get_string( &((*this_).temp_string) )
405 : );
406 : }
407 32 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_UUID ) )
408 : {
409 16 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
410 16 : result |= data_classifier_set_uuid( out_object,
411 16 : utf8stringbuf_get_string( &((*this_).temp_string) )
412 : );
413 : }
414 16 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_CLASSIFIER_FEATURES ) )
415 : {
416 16 : 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 16 : if ( U8_ERROR_NONE == result )
441 : {
442 16 : data_classifier_trace( out_object );
443 : }
444 :
445 16 : *out_has_features_array = break_at_features;
446 16 : U8_TRACE_END_ERR( result );
447 16 : return result;
448 : }
449 :
450 29 : u8_error_t json_element_reader_end_unfinished_object ( json_element_reader_t *this_ )
451 : {
452 29 : U8_TRACE_BEGIN();
453 29 : u8_error_t result = U8_ERROR_NONE;
454 :
455 29 : bool object_end = false;
456 29 : result = json_token_reader_check_end_object ( &((*this_).tokenizer), &object_end );
457 29 : if ( U8_ERROR_NONE == result )
458 : {
459 29 : if (! object_end)
460 : {
461 0 : result = U8_ERROR_PARSER_STRUCTURE;
462 : }
463 : }
464 :
465 29 : U8_TRACE_END_ERR( result );
466 29 : return result;
467 : }
468 :
469 17 : 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 17 : U8_TRACE_BEGIN();
475 17 : assert ( NULL != out_object );
476 17 : assert ( NULL != out_has_diagramelements_array );
477 17 : u8_error_t result = U8_ERROR_NONE;
478 :
479 : char member_name_buf[24];
480 17 : utf8stringbuf_t member_name = UTF8STRINGBUF( member_name_buf );
481 :
482 17 : data_diagram_init_empty( out_object );
483 17 : utf8stringbuf_clear( &out_parent_uuid );
484 :
485 : /* header */
486 :
487 17 : result = json_token_reader_expect_begin_object ( &((*this_).tokenizer) );
488 :
489 : /* members */
490 :
491 17 : bool first_member_passed = false;
492 17 : bool object_end = false;
493 17 : bool break_at_subelements = false;
494 183 : while (( ! object_end )&&( ! break_at_subelements )&&( U8_ERROR_NONE == result ))
495 : {
496 166 : result = json_token_reader_check_end_object ( &((*this_).tokenizer), &object_end );
497 166 : if ( U8_ERROR_NONE == result )
498 : {
499 166 : if ( ! object_end )
500 : {
501 164 : if ( first_member_passed )
502 : {
503 148 : result = json_token_reader_expect_value_separator ( &((*this_).tokenizer) );
504 : }
505 : else
506 : {
507 16 : first_member_passed = true;
508 : }
509 164 : if ( U8_ERROR_NONE == result )
510 : {
511 164 : result = json_token_reader_read_member_name ( &((*this_).tokenizer), member_name );
512 : }
513 164 : if ( U8_ERROR_NONE == result )
514 : {
515 164 : result = json_token_reader_expect_name_separator ( &((*this_).tokenizer) );
516 : }
517 164 : if ( U8_ERROR_NONE == result )
518 : {
519 164 : if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAM_ID ) )
520 : {
521 : int64_t parsed_integer;
522 16 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
523 16 : data_diagram_set_row ( out_object, parsed_integer );
524 : }
525 148 : 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 148 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAM_PARENT_NAME ) )
532 : {
533 14 : result = json_element_reader_skip_next_string( this_ );
534 : }
535 134 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAM_DIAGRAM_TYPE )
536 118 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_TYPE_ID ) )
537 16 : {
538 : int64_t parsed_integer;
539 16 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
540 16 : data_diagram_set_diagram_type ( out_object, parsed_integer );
541 : }
542 118 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_TYPE_NAME ) )
543 : {
544 14 : result = json_element_reader_skip_next_string( this_ );
545 : }
546 104 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAM_LIST_ORDER )
547 88 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_ORDER ) )
548 16 : {
549 : int64_t parsed_integer;
550 16 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
551 16 : data_diagram_set_list_order ( out_object, parsed_integer );
552 : }
553 88 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAM_DESCRIPTION ) )
554 : {
555 16 : result = json_element_reader_private_read_string_array( this_, (*this_).temp_string );
556 16 : data_diagram_set_description( out_object,
557 16 : utf8stringbuf_get_string( &((*this_).temp_string) )
558 : );
559 : }
560 72 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAM_NAME ) )
561 : {
562 16 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
563 16 : result |= data_diagram_set_name( out_object,
564 16 : utf8stringbuf_get_string( &((*this_).temp_string) )
565 : );
566 : }
567 56 : 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 56 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAM_DISPLAY_FLAGS ) )
576 : {
577 : int64_t parsed_integer;
578 14 : result = json_token_reader_read_int_value( &((*this_).tokenizer), &parsed_integer );
579 14 : data_diagram_set_display_flags ( out_object, parsed_integer );
580 : }
581 42 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAM_DISPLAY_FLAG_NAMES ) )
582 : {
583 14 : result = json_element_reader_skip_next_string( this_ );
584 : }
585 28 : 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 28 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_UUID ) )
590 : {
591 14 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
592 14 : result |= data_diagram_set_uuid( out_object,
593 14 : utf8stringbuf_get_string( &((*this_).temp_string) )
594 : );
595 : }
596 14 : 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 14 : 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 17 : if ( U8_ERROR_NONE == result )
624 : {
625 16 : data_diagram_trace( out_object );
626 : }
627 :
628 17 : *out_has_diagramelements_array = break_at_subelements;
629 17 : U8_TRACE_END_ERR( result );
630 17 : return result;
631 : }
632 :
633 14 : 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 14 : U8_TRACE_BEGIN();
640 14 : assert( NULL != out_object );
641 14 : u8_error_t result = U8_ERROR_NONE;
642 :
643 : char member_name_buf[24];
644 14 : utf8stringbuf_t member_name = UTF8STRINGBUF( member_name_buf );
645 :
646 14 : data_relationship_init_empty( out_object );
647 14 : utf8stringbuf_clear( &out_from_node_uuid );
648 14 : utf8stringbuf_clear( &out_to_node_uuid );
649 :
650 : /* header */
651 :
652 14 : result = json_token_reader_expect_begin_object ( &((*this_).tokenizer) );
653 :
654 : /* members */
655 :
656 14 : bool first_member_passed = false;
657 14 : bool object_end = false;
658 254 : while (( ! object_end )&&( U8_ERROR_NONE == result ))
659 : {
660 240 : result = json_token_reader_check_end_object ( &((*this_).tokenizer), &object_end );
661 240 : if ( U8_ERROR_NONE == result )
662 : {
663 240 : if ( ! object_end )
664 : {
665 226 : if ( first_member_passed )
666 : {
667 212 : result = json_token_reader_expect_value_separator ( &((*this_).tokenizer) );
668 : }
669 : else
670 : {
671 14 : first_member_passed = true;
672 : }
673 226 : if ( U8_ERROR_NONE == result )
674 : {
675 226 : result = json_token_reader_read_member_name ( &((*this_).tokenizer), member_name );
676 : }
677 226 : if ( U8_ERROR_NONE == result )
678 : {
679 226 : result = json_token_reader_expect_name_separator ( &((*this_).tokenizer) );
680 : }
681 226 : if ( U8_ERROR_NONE == result )
682 : {
683 226 : if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_ID ) )
684 : {
685 : int64_t parsed_integer;
686 14 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
687 14 : data_relationship_set_row ( out_object, parsed_integer );
688 : }
689 212 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_MAIN_TYPE )
690 198 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_TYPE_ID ) )
691 14 : {
692 : int64_t parsed_integer;
693 14 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
694 14 : data_relationship_set_main_type ( out_object, parsed_integer );
695 : }
696 198 : 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 191 : 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 191 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_LIST_ORDER )
709 177 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_ORDER ) )
710 14 : {
711 : int64_t parsed_integer;
712 14 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
713 14 : data_relationship_set_list_order ( out_object, parsed_integer );
714 : }
715 177 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_DESCRIPTION ) )
716 : {
717 14 : result = json_element_reader_private_read_string_array( this_, (*this_).temp_string );
718 14 : data_relationship_set_description( out_object,
719 14 : utf8stringbuf_get_string( &((*this_).temp_string) )
720 : );
721 : }
722 163 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_NAME ) )
723 : {
724 14 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
725 14 : data_relationship_set_name( out_object,
726 14 : utf8stringbuf_get_string( &((*this_).temp_string) )
727 : );
728 : }
729 149 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_FROM_CLASSIFIER_ID ) )
730 : {
731 : int64_t parsed_integer;
732 14 : result = json_token_reader_read_int_value( &((*this_).tokenizer), &parsed_integer );
733 14 : data_relationship_set_from_classifier_row ( out_object, parsed_integer );
734 : }
735 135 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_FROM_CLASSIFIER_NAME )
736 121 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_FROM_NODE_NAME ) )
737 : {
738 14 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
739 14 : U8_TRACE_INFO_STR( "from-classifier name:", utf8stringbuf_get_string( &((*this_).temp_string) ) );
740 : }
741 121 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_FROM_FEATURE_ID ) )
742 : {
743 : int64_t parsed_integer;
744 14 : result = json_token_reader_read_int_value( &((*this_).tokenizer), &parsed_integer );
745 14 : data_relationship_set_from_feature_row ( out_object, parsed_integer );
746 : }
747 107 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_FROM_FEATURE_KEY )
748 93 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_FROM_PORT_NAME ) )
749 : {
750 14 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
751 14 : U8_TRACE_INFO_STR( "from-feature key:", utf8stringbuf_get_string( &((*this_).temp_string) ) );
752 : }
753 93 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_TO_CLASSIFIER_ID ) )
754 : {
755 : int64_t parsed_integer;
756 14 : result = json_token_reader_read_int_value( &((*this_).tokenizer), &parsed_integer );
757 14 : data_relationship_set_to_classifier_row ( out_object, parsed_integer );
758 : }
759 79 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_TO_CLASSIFIER_NAME )
760 65 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_TO_NODE_NAME ) )
761 : {
762 14 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
763 14 : U8_TRACE_INFO_STR( "to-classifier name:", utf8stringbuf_get_string( &((*this_).temp_string) ) );
764 : }
765 65 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_TO_FEATURE_ID ) )
766 : {
767 : int64_t parsed_integer;
768 14 : result = json_token_reader_read_int_value( &((*this_).tokenizer), &parsed_integer );
769 14 : data_relationship_set_to_feature_row ( out_object, parsed_integer );
770 : }
771 51 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_TO_FEATURE_KEY )
772 37 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_TO_PORT_NAME ) )
773 : {
774 :
775 14 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
776 14 : U8_TRACE_INFO_STR( "to-feature key:", utf8stringbuf_get_string( &((*this_).temp_string) ) );
777 : }
778 37 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_FROM_NODE )
779 23 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_FROM_NODE_UUID ) )
780 : {
781 14 : result = json_token_reader_read_string_value( &((*this_).tokenizer), out_from_node_uuid );
782 : }
783 23 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_TO_NODE )
784 9 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_RELATIONSHIP_TO_NODE_UUID ) )
785 : {
786 14 : result = json_token_reader_read_string_value( &((*this_).tokenizer), out_to_node_uuid );
787 : }
788 9 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_UUID ) )
789 : {
790 9 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
791 9 : result |= data_relationship_set_uuid( out_object,
792 9 : 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 14 : if ( U8_ERROR_NONE == result )
818 : {
819 14 : data_relationship_trace( out_object );
820 : }
821 :
822 14 : U8_TRACE_END_ERR( result );
823 14 : return result;
824 : }
825 :
826 21 : u8_error_t json_element_reader_skip_next_object ( json_element_reader_t *this_ )
827 : {
828 21 : U8_TRACE_BEGIN();
829 21 : u8_error_t result = U8_ERROR_NONE;
830 :
831 : char member_name_buf[24];
832 21 : utf8stringbuf_t member_name = UTF8STRINGBUF( member_name_buf );
833 :
834 : /* header */
835 :
836 21 : result = json_token_reader_expect_begin_object ( &((*this_).tokenizer) );
837 :
838 : /* members */
839 :
840 21 : bool first_member_passed = false;
841 21 : bool object_end = false;
842 63 : while (( ! object_end )&&( U8_ERROR_NONE == result ))
843 : {
844 42 : result = json_token_reader_check_end_object ( &((*this_).tokenizer), &object_end );
845 42 : if ( U8_ERROR_NONE == result )
846 : {
847 42 : 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 21 : U8_TRACE_END_ERR( result );
946 21 : return result;
947 : }
948 :
949 120 : u8_error_t json_element_reader_skip_next_string ( json_element_reader_t *this_ )
950 : {
951 120 : U8_TRACE_BEGIN();
952 120 : u8_error_t result = U8_ERROR_NONE;
953 : char dummy_str[4];
954 120 : utf8stringbuf_t dummy_strbuf = UTF8STRINGBUF ( dummy_str );
955 :
956 120 : result = json_token_reader_read_string_value ( &((*this_).tokenizer), dummy_strbuf );
957 120 : 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 71 : result = U8_ERROR_NONE;
961 : }
962 :
963 120 : U8_TRACE_END_ERR( result );
964 120 : return result;
965 : }
966 :
967 22 : uint32_t json_element_reader_get_read_line ( json_element_reader_t *this_ )
968 : {
969 22 : U8_TRACE_BEGIN();
970 :
971 22 : const uint32_t read_line = json_token_reader_get_input_line( &((*this_).tokenizer) );
972 22 : U8_TRACE_INFO_INT( "line", read_line );
973 :
974 22 : U8_TRACE_END();
975 22 : 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 201 : while (( ! object_end )&&( U8_ERROR_NONE == result ))
999 : {
1000 179 : result = json_token_reader_check_end_object ( &((*this_).tokenizer), &object_end );
1001 179 : if ( U8_ERROR_NONE == result )
1002 : {
1003 179 : if ( ! object_end )
1004 : {
1005 157 : if ( first_member_passed )
1006 : {
1007 135 : result = json_token_reader_expect_value_separator ( &((*this_).tokenizer) );
1008 : }
1009 : else
1010 : {
1011 22 : first_member_passed = true;
1012 : }
1013 157 : if ( U8_ERROR_NONE == result )
1014 : {
1015 157 : result = json_token_reader_read_member_name( &((*this_).tokenizer), member_name );
1016 : }
1017 157 : if ( U8_ERROR_NONE == result )
1018 : {
1019 157 : result = json_token_reader_expect_name_separator( &((*this_).tokenizer) );
1020 : }
1021 157 : if ( U8_ERROR_NONE == result )
1022 : {
1023 157 : 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 ( out_object, parsed_integer );
1028 : }
1029 135 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_FEATURE_MAIN_TYPE )
1030 113 : || 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 113 : 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 106 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_FEATURE_LIST_ORDER )
1041 84 : || 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 84 : 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 62 : 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 40 : 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 18 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_UUID ) )
1069 : {
1070 18 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
1071 18 : result |= data_feature_set_uuid( out_object,
1072 18 : 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 14 : 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 14 : U8_TRACE_BEGIN();
1111 14 : assert ( NULL != out_object );
1112 :
1113 14 : u8_error_t result = U8_ERROR_NONE;
1114 :
1115 : char member_name_buf[24];
1116 14 : utf8stringbuf_t member_name = UTF8STRINGBUF( member_name_buf );
1117 :
1118 14 : data_diagramelement_init_empty( out_object );
1119 :
1120 : /* header */
1121 :
1122 14 : result = json_token_reader_expect_begin_object ( &((*this_).tokenizer) );
1123 :
1124 : /* members */
1125 :
1126 14 : bool first_member_passed = false;
1127 14 : bool object_end = false;
1128 154 : while (( ! object_end )&&( U8_ERROR_NONE == result ))
1129 : {
1130 140 : result = json_token_reader_check_end_object ( &((*this_).tokenizer), &object_end );
1131 140 : if ( U8_ERROR_NONE == result )
1132 : {
1133 140 : if ( ! object_end )
1134 : {
1135 126 : if ( first_member_passed )
1136 : {
1137 112 : result = json_token_reader_expect_value_separator ( &((*this_).tokenizer) );
1138 : }
1139 : else
1140 : {
1141 14 : first_member_passed = true;
1142 : }
1143 126 : if ( U8_ERROR_NONE == result )
1144 : {
1145 126 : result = json_token_reader_read_member_name( &((*this_).tokenizer), member_name );
1146 : }
1147 126 : if ( U8_ERROR_NONE == result )
1148 : {
1149 126 : result = json_token_reader_expect_name_separator( &((*this_).tokenizer) );
1150 : }
1151 126 : if ( U8_ERROR_NONE == result )
1152 : {
1153 126 : if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAMELEMENT_ID ) )
1154 : {
1155 : int64_t parsed_integer;
1156 14 : result = json_token_reader_read_int_value( &((*this_).tokenizer), &parsed_integer );
1157 14 : data_diagramelement_set_row ( out_object, parsed_integer );
1158 : }
1159 112 : 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( out_object, parsed_integer );
1164 : }
1165 112 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAMELEMENT_CLASSIFIER_ID ) )
1166 : {
1167 : int64_t parsed_integer;
1168 14 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
1169 14 : data_diagramelement_set_classifier_row ( out_object, parsed_integer );
1170 : }
1171 98 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAMELEMENT_CLASSIFIER_NAME )
1172 84 : || utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAMELEMENT_NODE_NAME ) )
1173 : {
1174 14 : result = json_element_reader_skip_next_string( this_ );
1175 : }
1176 84 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAMELEMENT_FOCUSED_FEATURE_ID ) )
1177 : {
1178 : int64_t parsed_integer;
1179 14 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
1180 14 : data_diagramelement_set_focused_feature_row ( out_object, parsed_integer );
1181 : }
1182 70 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAMELEMENT_FOCUSED_FEATURE_NAME ) )
1183 : {
1184 14 : result = json_element_reader_skip_next_string( this_ );
1185 : }
1186 56 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAMELEMENT_DISPLAY_FLAGS ) )
1187 : {
1188 : int64_t parsed_integer;
1189 14 : result = json_token_reader_read_int_value ( &((*this_).tokenizer), &parsed_integer );
1190 14 : data_diagramelement_set_display_flags ( out_object, parsed_integer );
1191 : }
1192 42 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAMELEMENT_DISPLAY_FLAG_NAMES ) )
1193 : {
1194 14 : result = json_element_reader_skip_next_string( this_ );
1195 : }
1196 28 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_DIAGRAMELEMENT_NODE ) )
1197 : {
1198 14 : result = json_token_reader_read_string_value( &((*this_).tokenizer), out_node_uuid );
1199 : }
1200 14 : else if ( utf8stringbuf_equals_str( &member_name, JSON_CONSTANTS_KEY_UUID ) )
1201 : {
1202 14 : result = json_token_reader_read_string_value( &((*this_).tokenizer), (*this_).temp_string );
1203 14 : result |= data_diagramelement_set_uuid( out_object,
1204 14 : 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 14 : if ( U8_ERROR_NONE == result )
1230 : {
1231 14 : data_diagramelement_trace( out_object );
1232 : }
1233 :
1234 14 : U8_TRACE_END_ERR( result );
1235 14 : return result;
1236 : }
1237 :
1238 68 : u8_error_t json_element_reader_private_read_string_array ( json_element_reader_t *this_,
1239 : utf8stringbuf_t out_joined_string )
1240 : {
1241 68 : U8_TRACE_BEGIN();
1242 68 : u8_error_t result = U8_ERROR_NONE;
1243 :
1244 68 : utf8stringbuf_clear( &out_joined_string );
1245 :
1246 68 : result = json_token_reader_expect_begin_array( &((*this_).tokenizer) );
1247 :
1248 68 : bool end_array = false;
1249 68 : bool first_element_passed = false;
1250 206 : while (( ! end_array )&&( U8_ERROR_NONE == result ))
1251 : {
1252 138 : result = json_token_reader_check_end_array( &((*this_).tokenizer), &end_array );
1253 138 : if ( U8_ERROR_NONE == result )
1254 : {
1255 138 : if ( ! end_array )
1256 : {
1257 70 : if ( first_element_passed )
1258 : {
1259 15 : result = json_token_reader_expect_value_separator ( &((*this_).tokenizer) );
1260 : }
1261 : else
1262 : {
1263 55 : first_element_passed = true;
1264 : }
1265 70 : utf8stringbuf_t unused_remaining = utf8stringbuf_get_end( &out_joined_string );
1266 70 : 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 68 : U8_TRACE_END_ERR( result );
1279 68 : 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 : */
|
