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 541 : static inline data_revision_t data_database_reader_get_revision ( data_database_reader_t *this_ )
13 : {
14 541 : return data_database_get_revision( (*this_).database );
15 : }
16 :
17 : /* ================================ DIAGRAM ================================ */
18 :
19 108 : 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 108 : U8_TRACE_BEGIN();
24 108 : u8_error_t result = U8_ERROR_NONE;
25 :
26 108 : if ( (*this_).is_open )
27 : {
28 108 : 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 108 : U8_TRACE_END_ERR( result );
37 108 : return result;
38 : }
39 :
40 9 : 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 9 : U8_TRACE_BEGIN();
45 9 : u8_error_t result = U8_ERROR_NONE;
46 :
47 9 : if ( (*this_).is_open )
48 : {
49 9 : 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 9 : U8_TRACE_END_ERR( result );
58 9 : 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 58 : 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 58 : U8_TRACE_BEGIN();
90 58 : u8_error_t result = U8_ERROR_NONE;
91 :
92 58 : if ( (*this_).is_open )
93 : {
94 58 : 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 58 : U8_TRACE_END_ERR( result );
106 58 : return result;
107 : }
108 :
109 31 : 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 31 : U8_TRACE_BEGIN();
114 31 : u8_error_t result = U8_ERROR_NONE;
115 :
116 31 : if ( (*this_).is_open )
117 : {
118 31 : 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 31 : U8_TRACE_END_ERR( result );
130 31 : return result;
131 : }
132 :
133 24 : 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 24 : U8_TRACE_BEGIN();
138 24 : u8_error_t result = U8_ERROR_NONE;
139 :
140 24 : if ( (*this_).is_open )
141 : {
142 24 : 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 24 : U8_TRACE_END_ERR( result );
154 24 : 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 13 : 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 13 : U8_TRACE_BEGIN();
188 13 : u8_error_t result = U8_ERROR_NONE;
189 :
190 13 : if ( (*this_).is_open )
191 : {
192 13 : 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 13 : U8_TRACE_END_ERR( result );
204 13 : 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 69 : 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 69 : U8_TRACE_BEGIN();
236 69 : u8_error_t result = U8_ERROR_NONE;
237 :
238 69 : if ( (*this_).is_open )
239 : {
240 69 : 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 69 : U8_TRACE_END_ERR( result );
252 69 : 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 43 : 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 43 : U8_TRACE_BEGIN();
312 43 : u8_error_t result = U8_ERROR_NONE;
313 :
314 43 : if ( (*this_).is_open )
315 : {
316 43 : 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 43 : U8_TRACE_END_ERR( result );
328 43 : return result;
329 : }
330 :
331 3 : 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 3 : U8_TRACE_BEGIN();
336 3 : u8_error_t result = U8_ERROR_NONE;
337 :
338 3 : if ( (*this_).is_open )
339 : {
340 3 : 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 3 : U8_TRACE_END_ERR( result );
352 3 : return result;
353 : }
354 :
355 155 : 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 155 : U8_TRACE_BEGIN();
360 155 : u8_error_t result = U8_ERROR_NONE;
361 :
362 155 : if ( (*this_).is_open )
363 : {
364 155 : 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 155 : U8_TRACE_END_ERR( result );
376 155 : return result;
377 : }
378 :
379 9 : 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 9 : U8_TRACE_BEGIN();
384 9 : u8_error_t result = U8_ERROR_NONE;
385 :
386 9 : if ( (*this_).is_open )
387 : {
388 9 : 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 9 : U8_TRACE_END_ERR( result );
400 9 : return result;
401 : }
402 :
403 : /* ================================ FEATURE ================================ */
404 :
405 41 : 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 41 : U8_TRACE_BEGIN();
410 41 : u8_error_t result = U8_ERROR_NONE;
411 :
412 41 : if ( (*this_).is_open )
413 : {
414 41 : 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 41 : U8_TRACE_END_ERR( result );
426 41 : return result;
427 : }
428 :
429 33 : 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 33 : U8_TRACE_BEGIN();
434 33 : u8_error_t result = U8_ERROR_NONE;
435 :
436 33 : if ( (*this_).is_open )
437 : {
438 33 : 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 33 : U8_TRACE_END_ERR( result );
450 33 : return result;
451 : }
452 :
453 25 : 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 25 : U8_TRACE_BEGIN();
458 25 : u8_error_t result = U8_ERROR_NONE;
459 :
460 25 : if ( (*this_).is_open )
461 : {
462 25 : 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 25 : U8_TRACE_END_ERR( result );
474 25 : 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 31 : 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 31 : U8_TRACE_BEGIN();
508 31 : u8_error_t result = U8_ERROR_NONE;
509 :
510 31 : if ( (*this_).is_open )
511 : {
512 31 : 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 31 : U8_TRACE_END_ERR( result );
524 31 : return result;
525 : }
526 :
527 10 : 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 10 : U8_TRACE_BEGIN();
532 10 : u8_error_t result = U8_ERROR_NONE;
533 :
534 10 : if ( (*this_).is_open )
535 : {
536 10 : 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 10 : U8_TRACE_END_ERR( result );
548 10 : return result;
549 : }
550 :
551 47 : 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 47 : U8_TRACE_BEGIN();
556 47 : u8_error_t result = U8_ERROR_NONE;
557 :
558 47 : if ( (*this_).is_open )
559 : {
560 47 : 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 47 : U8_TRACE_END_ERR( result );
572 47 : return result;
573 : }
574 :
575 16 : 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 16 : U8_TRACE_BEGIN();
580 16 : u8_error_t result = U8_ERROR_NONE;
581 :
582 16 : if ( (*this_).is_open )
583 : {
584 16 : 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 16 : U8_TRACE_END_ERR( result );
596 16 : 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-2026 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 : */
|
