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