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 23 : static inline u8_error_t data_database_reader_get_diagram_ids_by_parent_id ( data_database_reader_t *this_,
107 : data_row_t parent_id,
108 : data_small_set_t *out_diagram_ids )
109 : {
110 23 : U8_TRACE_BEGIN();
111 23 : u8_error_t result = U8_ERROR_NONE;
112 :
113 23 : if ( (*this_).is_open )
114 : {
115 23 : result = data_database_diagram_reader_get_diagram_ids_by_parent_id( &((*this_).temp_diagram_reader),
116 : parent_id,
117 : out_diagram_ids
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 23 : U8_TRACE_END_ERR( result );
127 23 : return result;
128 : }
129 :
130 1 : static inline u8_error_t data_database_reader_get_diagram_ids_by_classifier_id ( data_database_reader_t *this_,
131 : data_row_t classifier_id,
132 : data_small_set_t *out_diagram_ids )
133 : {
134 1 : U8_TRACE_BEGIN();
135 1 : u8_error_t result = U8_ERROR_NONE;
136 :
137 1 : if ( (*this_).is_open )
138 : {
139 1 : result = data_database_diagram_reader_get_diagram_ids_by_classifier_id( &((*this_).temp_diagram_reader),
140 : classifier_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 1 : U8_TRACE_END_ERR( result );
151 1 : return result;
152 : }
153 :
154 : /* ================================ CLASSIFIER ================================ */
155 :
156 12 : static inline u8_error_t data_database_reader_get_classifier_by_id ( data_database_reader_t *this_,
157 : data_row_t id,
158 : data_classifier_t *out_classifier )
159 : {
160 12 : U8_TRACE_BEGIN();
161 12 : u8_error_t result = U8_ERROR_NONE;
162 :
163 12 : if ( (*this_).is_open )
164 : {
165 12 : result = data_database_classifier_reader_get_classifier_by_id( &((*this_).temp_classifier_reader),
166 : id,
167 : out_classifier
168 : );
169 : }
170 : else
171 : {
172 0 : result |= U8_ERROR_NO_DB;
173 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
174 : }
175 :
176 12 : U8_TRACE_END_ERR( result );
177 12 : return result;
178 : }
179 :
180 57 : static inline u8_error_t data_database_reader_get_classifier_by_name ( data_database_reader_t *this_,
181 : const char *name,
182 : data_classifier_t *out_classifier )
183 : {
184 57 : U8_TRACE_BEGIN();
185 57 : u8_error_t result = U8_ERROR_NONE;
186 :
187 57 : if ( (*this_).is_open )
188 : {
189 57 : result = data_database_classifier_reader_get_classifier_by_name( &((*this_).temp_classifier_reader),
190 : name,
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 57 : U8_TRACE_END_ERR( result );
201 57 : return result;
202 : }
203 :
204 72 : static inline u8_error_t data_database_reader_get_classifier_by_uuid ( data_database_reader_t *this_,
205 : const char *uuid,
206 : data_classifier_t *out_classifier )
207 : {
208 72 : U8_TRACE_BEGIN();
209 72 : u8_error_t result = U8_ERROR_NONE;
210 :
211 72 : if ( (*this_).is_open )
212 : {
213 72 : result = data_database_classifier_reader_get_classifier_by_uuid( &((*this_).temp_classifier_reader),
214 : uuid,
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 72 : U8_TRACE_END_ERR( result );
225 72 : return result;
226 : }
227 :
228 5 : static inline u8_error_t data_database_reader_get_all_classifiers ( data_database_reader_t *this_,
229 : bool hierarchical,
230 : data_classifier_iterator_t *io_classifier_iterator )
231 : {
232 5 : U8_TRACE_BEGIN();
233 5 : u8_error_t result = U8_ERROR_NONE;
234 :
235 5 : if ( (*this_).is_open )
236 : {
237 5 : result = data_database_classifier_reader_get_all_classifiers( &((*this_).temp_classifier_reader),
238 : hierarchical,
239 : io_classifier_iterator
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 5 : U8_TRACE_END_ERR( result );
249 5 : return result;
250 : }
251 :
252 : /* ================================ VISIBLE_CLASSIFIER ================================ */
253 :
254 12 : static inline u8_error_t data_database_reader_get_visible_classifiers_by_diagram_id( data_database_reader_t *this_,
255 : data_row_t diagram_id,
256 : data_visible_classifier_iterator_t *io_visible_classifier_iterator )
257 : {
258 12 : U8_TRACE_BEGIN();
259 12 : u8_error_t result = U8_ERROR_NONE;
260 :
261 12 : if ( (*this_).is_open )
262 : {
263 12 : result = data_database_diagram_reader_get_visible_classifiers_by_diagram_id( &((*this_).temp_diagram_reader),
264 : diagram_id,
265 : io_visible_classifier_iterator
266 : );
267 : }
268 : else
269 : {
270 0 : result |= U8_ERROR_NO_DB;
271 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
272 : }
273 :
274 12 : U8_TRACE_END_ERR( result );
275 12 : return result;
276 : }
277 :
278 : /* ================================ DIAGRAMELEMENT ================================ */
279 :
280 38 : static inline u8_error_t data_database_reader_get_diagramelement_by_id ( data_database_reader_t *this_,
281 : data_row_t id,
282 : data_diagramelement_t *out_diagramelement )
283 : {
284 38 : U8_TRACE_BEGIN();
285 38 : u8_error_t result = U8_ERROR_NONE;
286 :
287 38 : if ( (*this_).is_open )
288 : {
289 38 : result = data_database_diagram_reader_get_diagramelement_by_id( &((*this_).temp_diagram_reader),
290 : id,
291 : out_diagramelement
292 : );
293 : }
294 : else
295 : {
296 0 : result |= U8_ERROR_NO_DB;
297 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
298 : }
299 :
300 38 : U8_TRACE_END_ERR( result );
301 38 : return result;
302 : }
303 :
304 2 : static inline u8_error_t data_database_reader_get_diagramelement_by_uuid ( data_database_reader_t *this_,
305 : const char *uuid,
306 : data_diagramelement_t *out_diagramelement )
307 : {
308 2 : U8_TRACE_BEGIN();
309 2 : u8_error_t result = U8_ERROR_NONE;
310 :
311 2 : if ( (*this_).is_open )
312 : {
313 2 : result = data_database_diagram_reader_get_diagramelement_by_uuid( &((*this_).temp_diagram_reader),
314 : uuid,
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 2 : U8_TRACE_END_ERR( result );
325 2 : return result;
326 : }
327 :
328 139 : static inline u8_error_t data_database_reader_get_diagramelements_by_diagram_id ( data_database_reader_t *this_,
329 : data_row_t diagram_id,
330 : data_diagramelement_iterator_t *io_diagramelement_iterator )
331 : {
332 139 : U8_TRACE_BEGIN();
333 139 : u8_error_t result = U8_ERROR_NONE;
334 :
335 139 : if ( (*this_).is_open )
336 : {
337 139 : result = data_database_diagram_reader_get_diagramelements_by_diagram_id( &((*this_).temp_diagram_reader),
338 : diagram_id,
339 : io_diagramelement_iterator
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 139 : U8_TRACE_END_ERR( result );
349 139 : return result;
350 : }
351 :
352 10 : static inline u8_error_t data_database_reader_get_diagramelements_by_classifier_id ( data_database_reader_t *this_,
353 : data_row_t classifier_id,
354 : data_diagramelement_iterator_t *io_diagramelement_iterator )
355 : {
356 10 : U8_TRACE_BEGIN();
357 10 : u8_error_t result = U8_ERROR_NONE;
358 :
359 10 : if ( (*this_).is_open )
360 : {
361 10 : result = data_database_diagram_reader_get_diagramelements_by_classifier_id( &((*this_).temp_diagram_reader),
362 : classifier_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 10 : U8_TRACE_END_ERR( result );
373 10 : return result;
374 : }
375 :
376 : /* ================================ FEATURE ================================ */
377 :
378 31 : static inline u8_error_t data_database_reader_get_feature_by_id ( data_database_reader_t *this_,
379 : data_row_t id,
380 : data_feature_t *out_feature )
381 : {
382 31 : U8_TRACE_BEGIN();
383 31 : u8_error_t result = U8_ERROR_NONE;
384 :
385 31 : if ( (*this_).is_open )
386 : {
387 31 : result = data_database_classifier_reader_get_feature_by_id( &((*this_).temp_classifier_reader),
388 : id,
389 : out_feature
390 : );
391 : }
392 : else
393 : {
394 0 : result |= U8_ERROR_NO_DB;
395 0 : U8_TRACE_INFO( "Database not open, cannot request data." );
396 : }
397 :
398 31 : U8_TRACE_END_ERR( result );
399 31 : return result;
400 : }
401 :
402 35 : static inline u8_error_t data_database_reader_get_feature_by_uuid ( data_database_reader_t *this_,
403 : const char *uuid,
404 : data_feature_t *out_feature )
405 : {
406 35 : U8_TRACE_BEGIN();
407 35 : u8_error_t result = U8_ERROR_NONE;
408 :
409 35 : if ( (*this_).is_open )
410 : {
411 35 : result = data_database_classifier_reader_get_feature_by_uuid( &((*this_).temp_classifier_reader),
412 : uuid,
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 35 : U8_TRACE_END_ERR( result );
423 35 : return result;
424 : }
425 :
426 13 : static inline u8_error_t data_database_reader_get_features_by_classifier_id ( data_database_reader_t *this_,
427 : data_row_t classifier_id,
428 : data_feature_iterator_t *io_feature_iterator )
429 : {
430 13 : U8_TRACE_BEGIN();
431 13 : u8_error_t result = U8_ERROR_NONE;
432 :
433 13 : if ( (*this_).is_open )
434 : {
435 13 : result = data_database_classifier_reader_get_features_by_classifier_id( &((*this_).temp_classifier_reader),
436 : classifier_id,
437 : io_feature_iterator
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 13 : U8_TRACE_END_ERR( result );
447 13 : return result;
448 : }
449 :
450 8 : static inline u8_error_t data_database_reader_get_features_by_diagram_id ( data_database_reader_t *this_,
451 : data_row_t diagram_id,
452 : data_feature_iterator_t *io_feature_iterator )
453 : {
454 8 : U8_TRACE_BEGIN();
455 8 : u8_error_t result = U8_ERROR_NONE;
456 :
457 8 : if ( (*this_).is_open )
458 : {
459 8 : result = data_database_classifier_reader_get_features_by_diagram_id( &((*this_).temp_classifier_reader),
460 : diagram_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 8 : U8_TRACE_END_ERR( result );
471 8 : return result;
472 : }
473 :
474 : /* ================================ RELATIONSHIP ================================ */
475 :
476 25 : static inline u8_error_t data_database_reader_get_relationship_by_id ( data_database_reader_t *this_,
477 : data_row_t id,
478 : data_relationship_t *out_relationship )
479 : {
480 25 : U8_TRACE_BEGIN();
481 25 : u8_error_t result = U8_ERROR_NONE;
482 :
483 25 : if ( (*this_).is_open )
484 : {
485 25 : result = data_database_classifier_reader_get_relationship_by_id( &((*this_).temp_classifier_reader),
486 : id,
487 : out_relationship
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 25 : U8_TRACE_END_ERR( result );
497 25 : return result;
498 : }
499 :
500 9 : static inline u8_error_t data_database_reader_get_relationship_by_uuid ( data_database_reader_t *this_,
501 : const char *uuid,
502 : data_relationship_t *out_relationship )
503 : {
504 9 : U8_TRACE_BEGIN();
505 9 : u8_error_t result = U8_ERROR_NONE;
506 :
507 9 : if ( (*this_).is_open )
508 : {
509 9 : result = data_database_classifier_reader_get_relationship_by_uuid( &((*this_).temp_classifier_reader),
510 : uuid,
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 9 : U8_TRACE_END_ERR( result );
521 9 : return result;
522 : }
523 :
524 13 : static inline u8_error_t data_database_reader_get_relationships_by_classifier_id ( data_database_reader_t *this_,
525 : data_row_t classifier_id,
526 : data_relationship_iterator_t *io_relationship_iterator )
527 : {
528 13 : U8_TRACE_BEGIN();
529 13 : u8_error_t result = U8_ERROR_NONE;
530 :
531 13 : if ( (*this_).is_open )
532 : {
533 13 : result = data_database_classifier_reader_get_relationships_by_classifier_id( &((*this_).temp_classifier_reader),
534 : classifier_id,
535 : io_relationship_iterator
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 13 : U8_TRACE_END_ERR( result );
545 13 : return result;
546 : }
547 :
548 10 : static inline u8_error_t data_database_reader_get_relationships_by_feature_id ( data_database_reader_t *this_,
549 : data_row_t feature_id,
550 : data_relationship_iterator_t *io_relationship_iterator )
551 : {
552 10 : U8_TRACE_BEGIN();
553 10 : u8_error_t result = U8_ERROR_NONE;
554 :
555 10 : if ( (*this_).is_open )
556 : {
557 10 : result = data_database_classifier_reader_get_relationships_by_feature_id( &((*this_).temp_classifier_reader),
558 : feature_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 10 : U8_TRACE_END_ERR( result );
569 10 : return result;
570 : }
571 :
572 8 : static inline u8_error_t data_database_reader_get_relationships_by_diagram_id ( data_database_reader_t *this_,
573 : data_row_t diagram_id,
574 : data_relationship_iterator_t *io_relationship_iterator )
575 : {
576 8 : U8_TRACE_BEGIN();
577 8 : u8_error_t result = U8_ERROR_NONE;
578 :
579 8 : if ( (*this_).is_open )
580 : {
581 8 : result = data_database_classifier_reader_get_relationships_by_diagram_id( &((*this_).temp_classifier_reader),
582 : diagram_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 8 : U8_TRACE_END_ERR( result );
593 8 : return result;
594 : }
595 :
596 :
597 : /*
598 : Copyright 2016-2024 Andreas Warnke
599 :
600 : Licensed under the Apache License, Version 2.0 (the "License");
601 : you may not use this file except in compliance with the License.
602 : You may obtain a copy of the License at
603 :
604 : http://www.apache.org/licenses/LICENSE-2.0
605 :
606 : Unless required by applicable law or agreed to in writing, software
607 : distributed under the License is distributed on an "AS IS" BASIS,
608 : WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
609 : See the License for the specific language governing permissions and
610 : limitations under the License.
611 : */
|
