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