Line data Source code
1 : /* File: data_database_reader.inl; Copyright and License: see below */
2 :
3 : #include "u8/u8_log.h"
4 : #include "u8/u8_trace.h"
5 : #include <assert.h>
6 :
7 0 : static inline bool data_database_reader_is_open( data_database_reader_t *this_ )
8 : {
9 : bool result;
10 0 : result = (*this_).is_open;
11 0 : return result;
12 : }
13 :
14 : /* ================================ DIAGRAM ================================ */
15 :
16 75 : static inline u8_error_t data_database_reader_get_diagram_by_id( data_database_reader_t *this_,
17 : data_row_t id,
18 : data_diagram_t *out_diagram )
19 : {
20 75 : U8_TRACE_BEGIN();
21 75 : u8_error_t result = U8_ERROR_NONE;
22 :
23 75 : if ( (*this_).is_open )
24 : {
25 75 : result = data_database_diagram_reader_get_diagram_by_id( &((*this_).temp_diagram_reader), id, out_diagram );
26 : }
27 : else
28 : {
29 0 : result |= U8_ERROR_NO_DB;
30 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
31 : }
32 :
33 75 : U8_TRACE_END_ERR( result );
34 75 : return result;
35 : }
36 :
37 10 : static inline u8_error_t data_database_reader_get_diagram_by_uuid( data_database_reader_t *this_,
38 : const char *uuid,
39 : data_diagram_t *out_diagram )
40 : {
41 10 : U8_TRACE_BEGIN();
42 10 : u8_error_t result = U8_ERROR_NONE;
43 :
44 10 : if ( (*this_).is_open )
45 : {
46 10 : result = data_database_diagram_reader_get_diagram_by_uuid( &((*this_).temp_diagram_reader), uuid, out_diagram );
47 : }
48 : else
49 : {
50 0 : result |= U8_ERROR_NO_DB;
51 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
52 : }
53 :
54 10 : U8_TRACE_END_ERR( result );
55 10 : return result;
56 : }
57 :
58 175 : static inline u8_error_t data_database_reader_get_diagrams_by_parent_id ( data_database_reader_t *this_,
59 : data_row_t parent_id,
60 : data_diagram_iterator_t *io_diagram_iterator )
61 : {
62 175 : U8_TRACE_BEGIN();
63 175 : u8_error_t result = U8_ERROR_NONE;
64 :
65 175 : if ( (*this_).is_open )
66 : {
67 175 : result = data_database_diagram_reader_get_diagrams_by_parent_id( &((*this_).temp_diagram_reader),
68 : parent_id,
69 : io_diagram_iterator
70 : );
71 : }
72 : else
73 : {
74 0 : result |= U8_ERROR_NO_DB;
75 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
76 : }
77 :
78 175 : U8_TRACE_END_ERR( result );
79 175 : return result;
80 : }
81 :
82 14 : static inline u8_error_t data_database_reader_get_diagrams_by_classifier_id( data_database_reader_t *this_,
83 : data_row_t classifier_id,
84 : data_diagram_iterator_t *io_diagram_iterator )
85 : {
86 14 : U8_TRACE_BEGIN();
87 14 : u8_error_t result = U8_ERROR_NONE;
88 :
89 14 : if ( (*this_).is_open )
90 : {
91 14 : result = data_database_diagram_reader_get_diagrams_by_classifier_id( &((*this_).temp_diagram_reader),
92 : classifier_id,
93 : io_diagram_iterator
94 : );
95 : }
96 : else
97 : {
98 0 : result |= U8_ERROR_NO_DB;
99 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
100 : }
101 :
102 14 : U8_TRACE_END_ERR( result );
103 14 : return result;
104 : }
105 :
106 0 : static inline u8_error_t data_database_reader_get_diagrams_by_relationship_id( data_database_reader_t *this_,
107 : data_row_t relationship_id,
108 : data_diagram_iterator_t *io_diagram_iterator )
109 : {
110 0 : U8_TRACE_BEGIN();
111 0 : u8_error_t result = U8_ERROR_NONE;
112 :
113 0 : if ( (*this_).is_open )
114 : {
115 0 : result = data_database_diagram_reader_get_diagrams_by_relationship_id( &((*this_).temp_diagram_reader),
116 : relationship_id,
117 : io_diagram_iterator
118 : );
119 : }
120 : else
121 : {
122 0 : result |= U8_ERROR_NO_DB;
123 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
124 : }
125 :
126 0 : U8_TRACE_END_ERR( result );
127 0 : return result;
128 : }
129 :
130 23 : static inline u8_error_t data_database_reader_get_diagram_ids_by_parent_id( data_database_reader_t *this_,
131 : data_row_t parent_id,
132 : data_small_set_t *out_diagram_ids )
133 : {
134 23 : U8_TRACE_BEGIN();
135 23 : u8_error_t result = U8_ERROR_NONE;
136 :
137 23 : if ( (*this_).is_open )
138 : {
139 23 : result = data_database_diagram_reader_get_diagram_ids_by_parent_id( &((*this_).temp_diagram_reader),
140 : parent_id,
141 : out_diagram_ids
142 : );
143 : }
144 : else
145 : {
146 0 : result |= U8_ERROR_NO_DB;
147 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
148 : }
149 :
150 23 : U8_TRACE_END_ERR( result );
151 23 : return result;
152 : }
153 :
154 1 : static inline u8_error_t data_database_reader_get_diagram_ids_by_classifier_id( data_database_reader_t *this_,
155 : data_row_t classifier_id,
156 : data_small_set_t *out_diagram_ids )
157 : {
158 1 : U8_TRACE_BEGIN();
159 1 : u8_error_t result = U8_ERROR_NONE;
160 :
161 1 : if ( (*this_).is_open )
162 : {
163 1 : result = data_database_diagram_reader_get_diagram_ids_by_classifier_id( &((*this_).temp_diagram_reader),
164 : classifier_id,
165 : out_diagram_ids
166 : );
167 : }
168 : else
169 : {
170 0 : result |= U8_ERROR_NO_DB;
171 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
172 : }
173 :
174 1 : U8_TRACE_END_ERR( result );
175 1 : return result;
176 : }
177 :
178 : /* ================================ CLASSIFIER ================================ */
179 :
180 12 : static inline u8_error_t data_database_reader_get_classifier_by_id ( data_database_reader_t *this_,
181 : data_row_t id,
182 : data_classifier_t *out_classifier )
183 : {
184 12 : U8_TRACE_BEGIN();
185 12 : u8_error_t result = U8_ERROR_NONE;
186 :
187 12 : if ( (*this_).is_open )
188 : {
189 12 : result = data_database_classifier_reader_get_classifier_by_id( &((*this_).temp_classifier_reader),
190 : id,
191 : out_classifier
192 : );
193 : }
194 : else
195 : {
196 0 : result |= U8_ERROR_NO_DB;
197 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
198 : }
199 :
200 12 : U8_TRACE_END_ERR( result );
201 12 : return result;
202 : }
203 :
204 57 : static inline u8_error_t data_database_reader_get_classifier_by_name ( data_database_reader_t *this_,
205 : const char *name,
206 : data_classifier_t *out_classifier )
207 : {
208 57 : U8_TRACE_BEGIN();
209 57 : u8_error_t result = U8_ERROR_NONE;
210 :
211 57 : if ( (*this_).is_open )
212 : {
213 57 : result = data_database_classifier_reader_get_classifier_by_name( &((*this_).temp_classifier_reader),
214 : name,
215 : out_classifier
216 : );
217 : }
218 : else
219 : {
220 0 : result |= U8_ERROR_NO_DB;
221 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
222 : }
223 :
224 57 : U8_TRACE_END_ERR( result );
225 57 : return result;
226 : }
227 :
228 72 : static inline u8_error_t data_database_reader_get_classifier_by_uuid ( data_database_reader_t *this_,
229 : const char *uuid,
230 : data_classifier_t *out_classifier )
231 : {
232 72 : U8_TRACE_BEGIN();
233 72 : u8_error_t result = U8_ERROR_NONE;
234 :
235 72 : if ( (*this_).is_open )
236 : {
237 72 : result = data_database_classifier_reader_get_classifier_by_uuid( &((*this_).temp_classifier_reader),
238 : uuid,
239 : out_classifier
240 : );
241 : }
242 : else
243 : {
244 0 : result |= U8_ERROR_NO_DB;
245 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
246 : }
247 :
248 72 : U8_TRACE_END_ERR( result );
249 72 : return result;
250 : }
251 :
252 5 : static inline u8_error_t data_database_reader_get_all_classifiers ( data_database_reader_t *this_,
253 : bool hierarchical,
254 : data_classifier_iterator_t *io_classifier_iterator )
255 : {
256 5 : U8_TRACE_BEGIN();
257 5 : u8_error_t result = U8_ERROR_NONE;
258 :
259 5 : if ( (*this_).is_open )
260 : {
261 5 : result = data_database_classifier_reader_get_all_classifiers( &((*this_).temp_classifier_reader),
262 : hierarchical,
263 : io_classifier_iterator
264 : );
265 : }
266 : else
267 : {
268 0 : result |= U8_ERROR_NO_DB;
269 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
270 : }
271 :
272 5 : U8_TRACE_END_ERR( result );
273 5 : return result;
274 : }
275 :
276 : /* ================================ VISIBLE_CLASSIFIER ================================ */
277 :
278 12 : static inline u8_error_t data_database_reader_get_visible_classifiers_by_diagram_id( data_database_reader_t *this_,
279 : data_row_t diagram_id,
280 : data_visible_classifier_iterator_t *io_visible_classifier_iterator )
281 : {
282 12 : U8_TRACE_BEGIN();
283 12 : u8_error_t result = U8_ERROR_NONE;
284 :
285 12 : if ( (*this_).is_open )
286 : {
287 12 : result = data_database_diagram_reader_get_visible_classifiers_by_diagram_id( &((*this_).temp_diagram_reader),
288 : diagram_id,
289 : io_visible_classifier_iterator
290 : );
291 : }
292 : else
293 : {
294 0 : result |= U8_ERROR_NO_DB;
295 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
296 : }
297 :
298 12 : U8_TRACE_END_ERR( result );
299 12 : return result;
300 : }
301 :
302 : /* ================================ DIAGRAMELEMENT ================================ */
303 :
304 38 : static inline u8_error_t data_database_reader_get_diagramelement_by_id ( data_database_reader_t *this_,
305 : data_row_t id,
306 : data_diagramelement_t *out_diagramelement )
307 : {
308 38 : U8_TRACE_BEGIN();
309 38 : u8_error_t result = U8_ERROR_NONE;
310 :
311 38 : if ( (*this_).is_open )
312 : {
313 38 : result = data_database_diagram_reader_get_diagramelement_by_id( &((*this_).temp_diagram_reader),
314 : id,
315 : out_diagramelement
316 : );
317 : }
318 : else
319 : {
320 0 : result |= U8_ERROR_NO_DB;
321 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
322 : }
323 :
324 38 : U8_TRACE_END_ERR( result );
325 38 : return result;
326 : }
327 :
328 2 : static inline u8_error_t data_database_reader_get_diagramelement_by_uuid ( data_database_reader_t *this_,
329 : const char *uuid,
330 : data_diagramelement_t *out_diagramelement )
331 : {
332 2 : U8_TRACE_BEGIN();
333 2 : u8_error_t result = U8_ERROR_NONE;
334 :
335 2 : if ( (*this_).is_open )
336 : {
337 2 : result = data_database_diagram_reader_get_diagramelement_by_uuid( &((*this_).temp_diagram_reader),
338 : uuid,
339 : out_diagramelement
340 : );
341 : }
342 : else
343 : {
344 0 : result |= U8_ERROR_NO_DB;
345 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
346 : }
347 :
348 2 : U8_TRACE_END_ERR( result );
349 2 : return result;
350 : }
351 :
352 139 : static inline u8_error_t data_database_reader_get_diagramelements_by_diagram_id ( data_database_reader_t *this_,
353 : data_row_t diagram_id,
354 : data_diagramelement_iterator_t *io_diagramelement_iterator )
355 : {
356 139 : U8_TRACE_BEGIN();
357 139 : u8_error_t result = U8_ERROR_NONE;
358 :
359 139 : if ( (*this_).is_open )
360 : {
361 139 : result = data_database_diagram_reader_get_diagramelements_by_diagram_id( &((*this_).temp_diagram_reader),
362 : diagram_id,
363 : io_diagramelement_iterator
364 : );
365 : }
366 : else
367 : {
368 0 : result |= U8_ERROR_NO_DB;
369 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
370 : }
371 :
372 139 : U8_TRACE_END_ERR( result );
373 139 : return result;
374 : }
375 :
376 10 : static inline u8_error_t data_database_reader_get_diagramelements_by_classifier_id ( data_database_reader_t *this_,
377 : data_row_t classifier_id,
378 : data_diagramelement_iterator_t *io_diagramelement_iterator )
379 : {
380 10 : U8_TRACE_BEGIN();
381 10 : u8_error_t result = U8_ERROR_NONE;
382 :
383 10 : if ( (*this_).is_open )
384 : {
385 10 : result = data_database_diagram_reader_get_diagramelements_by_classifier_id( &((*this_).temp_diagram_reader),
386 : classifier_id,
387 : io_diagramelement_iterator
388 : );
389 : }
390 : else
391 : {
392 0 : result |= U8_ERROR_NO_DB;
393 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
394 : }
395 :
396 10 : U8_TRACE_END_ERR( result );
397 10 : return result;
398 : }
399 :
400 : /* ================================ FEATURE ================================ */
401 :
402 31 : static inline u8_error_t data_database_reader_get_feature_by_id ( data_database_reader_t *this_,
403 : data_row_t id,
404 : data_feature_t *out_feature )
405 : {
406 31 : U8_TRACE_BEGIN();
407 31 : u8_error_t result = U8_ERROR_NONE;
408 :
409 31 : if ( (*this_).is_open )
410 : {
411 31 : result = data_database_classifier_reader_get_feature_by_id( &((*this_).temp_classifier_reader),
412 : id,
413 : out_feature
414 : );
415 : }
416 : else
417 : {
418 0 : result |= U8_ERROR_NO_DB;
419 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
420 : }
421 :
422 31 : U8_TRACE_END_ERR( result );
423 31 : return result;
424 : }
425 :
426 35 : static inline u8_error_t data_database_reader_get_feature_by_uuid ( data_database_reader_t *this_,
427 : const char *uuid,
428 : data_feature_t *out_feature )
429 : {
430 35 : U8_TRACE_BEGIN();
431 35 : u8_error_t result = U8_ERROR_NONE;
432 :
433 35 : if ( (*this_).is_open )
434 : {
435 35 : result = data_database_classifier_reader_get_feature_by_uuid( &((*this_).temp_classifier_reader),
436 : uuid,
437 : out_feature
438 : );
439 : }
440 : else
441 : {
442 0 : result |= U8_ERROR_NO_DB;
443 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
444 : }
445 :
446 35 : U8_TRACE_END_ERR( result );
447 35 : return result;
448 : }
449 :
450 13 : static inline u8_error_t data_database_reader_get_features_by_classifier_id ( data_database_reader_t *this_,
451 : data_row_t classifier_id,
452 : data_feature_iterator_t *io_feature_iterator )
453 : {
454 13 : U8_TRACE_BEGIN();
455 13 : u8_error_t result = U8_ERROR_NONE;
456 :
457 13 : if ( (*this_).is_open )
458 : {
459 13 : result = data_database_classifier_reader_get_features_by_classifier_id( &((*this_).temp_classifier_reader),
460 : classifier_id,
461 : io_feature_iterator
462 : );
463 : }
464 : else
465 : {
466 0 : result |= U8_ERROR_NO_DB;
467 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
468 : }
469 :
470 13 : U8_TRACE_END_ERR( result );
471 13 : return result;
472 : }
473 :
474 8 : static inline u8_error_t data_database_reader_get_features_by_diagram_id ( data_database_reader_t *this_,
475 : data_row_t diagram_id,
476 : data_feature_iterator_t *io_feature_iterator )
477 : {
478 8 : U8_TRACE_BEGIN();
479 8 : u8_error_t result = U8_ERROR_NONE;
480 :
481 8 : if ( (*this_).is_open )
482 : {
483 8 : result = data_database_classifier_reader_get_features_by_diagram_id( &((*this_).temp_classifier_reader),
484 : diagram_id,
485 : io_feature_iterator
486 : );
487 : }
488 : else
489 : {
490 0 : result |= U8_ERROR_NO_DB;
491 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
492 : }
493 :
494 8 : U8_TRACE_END_ERR( result );
495 8 : return result;
496 : }
497 :
498 : /* ================================ RELATIONSHIP ================================ */
499 :
500 25 : static inline u8_error_t data_database_reader_get_relationship_by_id ( data_database_reader_t *this_,
501 : data_row_t id,
502 : data_relationship_t *out_relationship )
503 : {
504 25 : U8_TRACE_BEGIN();
505 25 : u8_error_t result = U8_ERROR_NONE;
506 :
507 25 : if ( (*this_).is_open )
508 : {
509 25 : result = data_database_classifier_reader_get_relationship_by_id( &((*this_).temp_classifier_reader),
510 : id,
511 : out_relationship
512 : );
513 : }
514 : else
515 : {
516 0 : result |= U8_ERROR_NO_DB;
517 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
518 : }
519 :
520 25 : U8_TRACE_END_ERR( result );
521 25 : return result;
522 : }
523 :
524 9 : static inline u8_error_t data_database_reader_get_relationship_by_uuid ( data_database_reader_t *this_,
525 : const char *uuid,
526 : data_relationship_t *out_relationship )
527 : {
528 9 : U8_TRACE_BEGIN();
529 9 : u8_error_t result = U8_ERROR_NONE;
530 :
531 9 : if ( (*this_).is_open )
532 : {
533 9 : result = data_database_classifier_reader_get_relationship_by_uuid( &((*this_).temp_classifier_reader),
534 : uuid,
535 : out_relationship
536 : );
537 : }
538 : else
539 : {
540 0 : result |= U8_ERROR_NO_DB;
541 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
542 : }
543 :
544 9 : U8_TRACE_END_ERR( result );
545 9 : return result;
546 : }
547 :
548 13 : static inline u8_error_t data_database_reader_get_relationships_by_classifier_id ( data_database_reader_t *this_,
549 : data_row_t classifier_id,
550 : data_relationship_iterator_t *io_relationship_iterator )
551 : {
552 13 : U8_TRACE_BEGIN();
553 13 : u8_error_t result = U8_ERROR_NONE;
554 :
555 13 : if ( (*this_).is_open )
556 : {
557 13 : result = data_database_classifier_reader_get_relationships_by_classifier_id( &((*this_).temp_classifier_reader),
558 : classifier_id,
559 : io_relationship_iterator
560 : );
561 : }
562 : else
563 : {
564 0 : result |= U8_ERROR_NO_DB;
565 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
566 : }
567 :
568 13 : U8_TRACE_END_ERR( result );
569 13 : return result;
570 : }
571 :
572 10 : static inline u8_error_t data_database_reader_get_relationships_by_feature_id ( data_database_reader_t *this_,
573 : data_row_t feature_id,
574 : data_relationship_iterator_t *io_relationship_iterator )
575 : {
576 10 : U8_TRACE_BEGIN();
577 10 : u8_error_t result = U8_ERROR_NONE;
578 :
579 10 : if ( (*this_).is_open )
580 : {
581 10 : result = data_database_classifier_reader_get_relationships_by_feature_id( &((*this_).temp_classifier_reader),
582 : feature_id,
583 : io_relationship_iterator
584 : );
585 : }
586 : else
587 : {
588 0 : result |= U8_ERROR_NO_DB;
589 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
590 : }
591 :
592 10 : U8_TRACE_END_ERR( result );
593 10 : return result;
594 : }
595 :
596 8 : static inline u8_error_t data_database_reader_get_relationships_by_diagram_id ( data_database_reader_t *this_,
597 : data_row_t diagram_id,
598 : data_relationship_iterator_t *io_relationship_iterator )
599 : {
600 8 : U8_TRACE_BEGIN();
601 8 : u8_error_t result = U8_ERROR_NONE;
602 :
603 8 : if ( (*this_).is_open )
604 : {
605 8 : result = data_database_classifier_reader_get_relationships_by_diagram_id( &((*this_).temp_classifier_reader),
606 : diagram_id,
607 : io_relationship_iterator
608 : );
609 : }
610 : else
611 : {
612 0 : result |= U8_ERROR_NO_DB;
613 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
614 : }
615 :
616 8 : U8_TRACE_END_ERR( result );
617 8 : return result;
618 : }
619 :
620 :
621 : /*
622 : Copyright 2016-2025 Andreas Warnke
623 :
624 : Licensed under the Apache License, Version 2.0 (the "License");
625 : you may not use this file except in compliance with the License.
626 : You may obtain a copy of the License at
627 :
628 : http://www.apache.org/licenses/LICENSE-2.0
629 :
630 : Unless required by applicable law or agreed to in writing, software
631 : distributed under the License is distributed on an "AS IS" BASIS,
632 : WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
633 : See the License for the specific language governing permissions and
634 : limitations under the License.
635 : */
|
