lib: add internal BT_LIB_LOG*_APPEND_CAUSE() macros
[babeltrace.git] / src / lib / error.c
1 /*
2 * Copyright (c) 2019 Philippe Proulx <pproulx@efficios.com>
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a copy
5 * of this software and associated documentation files (the "Software"), to deal
6 * in the Software without restriction, including without limitation the rights
7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 * copies of the Software, and to permit persons to whom the Software is
9 * furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20 * SOFTWARE.
21 */
22
23 #define BT_LOG_TAG "LIB/ERROR"
24 #include "lib/logging.h"
25
26 #include <stdlib.h>
27 #include <stdint.h>
28 #include <babeltrace2/error-const.h>
29 #include <babeltrace2/error-cause-const.h>
30
31 #include "error.h"
32 #include "graph/message/iterator.h"
33 #include "graph/component.h"
34 #include "graph/component-class.h"
35 #include "common/assert.h"
36 #include "lib/assert-pre.h"
37 #include "lib/func-status.h"
38
39 #define BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(_cause, _exp_type) \
40 BT_ASSERT_PRE(((const struct bt_error_cause *) (_cause))->actor_type == _exp_type, \
41 "Unexpected error cause's actor type: type=%s, exp-type=%s", \
42 bt_error_cause_actor_type_string(((const struct bt_error_cause *) (_cause))->actor_type), \
43 bt_error_cause_actor_type_string(_exp_type))
44
45 static
46 void fini_component_class_id(
47 struct bt_error_cause_component_class_id *comp_class_id)
48 {
49 BT_ASSERT(comp_class_id);
50
51 if (comp_class_id->name) {
52 g_string_free(comp_class_id->name, TRUE);
53 comp_class_id->name = NULL;
54 }
55
56 if (comp_class_id->plugin_name) {
57 g_string_free(comp_class_id->plugin_name, TRUE);
58 comp_class_id->plugin_name = NULL;
59 }
60 }
61
62 static
63 void fini_error_cause(struct bt_error_cause *cause)
64 {
65 BT_ASSERT(cause);
66 BT_LIB_LOGD("Finalizing error cause: %!+r", cause);
67
68 if (cause->module_name) {
69 g_string_free(cause->module_name, TRUE);
70 cause->module_name = NULL;
71 }
72
73 if (cause->file_name) {
74 g_string_free(cause->file_name, TRUE);
75 cause->file_name = NULL;
76 }
77
78 if (cause->message) {
79 g_string_free(cause->message, TRUE);
80 cause->message = NULL;
81 }
82 }
83
84 static
85 void destroy_error_cause(struct bt_error_cause *cause)
86 {
87 if (!cause) {
88 goto end;
89 }
90
91 BT_LIB_LOGD("Destroying error cause: %!+r", cause);
92
93 switch (cause->actor_type) {
94 case BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT:
95 {
96 struct bt_error_cause_component_actor *spec_cause =
97 (void *) cause;
98
99 if (spec_cause->comp_name) {
100 g_string_free(spec_cause->comp_name, TRUE);
101 spec_cause->comp_name = NULL;
102 }
103
104 fini_component_class_id(&spec_cause->comp_class_id);
105 break;
106 }
107 case BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT_CLASS:
108 {
109 struct bt_error_cause_component_class_actor *spec_cause =
110 (void *) cause;
111
112 fini_component_class_id(&spec_cause->comp_class_id);
113 break;
114 }
115 case BT_ERROR_CAUSE_ACTOR_TYPE_MESSAGE_ITERATOR:
116 {
117 struct bt_error_cause_message_iterator_actor *spec_cause =
118 (void *) cause;
119
120 if (spec_cause->comp_name) {
121 g_string_free(spec_cause->comp_name, TRUE);
122 spec_cause->comp_name = NULL;
123 }
124
125 if (spec_cause->output_port_name) {
126 g_string_free(spec_cause->output_port_name, TRUE);
127 spec_cause->output_port_name = NULL;
128 }
129
130 fini_component_class_id(&spec_cause->comp_class_id);
131 break;
132 }
133 default:
134 break;
135 }
136
137 fini_error_cause(cause);
138 g_free(cause);
139
140 end:
141 return;
142 }
143
144 static
145 int init_error_cause(struct bt_error_cause *cause,
146 enum bt_error_cause_actor_type actor_type)
147 {
148 int ret = 0;
149
150 BT_ASSERT(cause);
151 BT_LIB_LOGD("Initializing error cause: %!+r", cause);
152 cause->actor_type = actor_type;
153 cause->module_name = g_string_new(NULL);
154 if (!cause->module_name) {
155 BT_LOGE_STR("Failed to allocate one GString.");
156 ret = -1;
157 goto end;
158 }
159
160 cause->message = g_string_new(NULL);
161 if (!cause->message) {
162 BT_LOGE_STR("Failed to allocate one GString.");
163 ret = -1;
164 goto end;
165 }
166
167 cause->file_name = g_string_new(NULL);
168 if (!cause->file_name) {
169 BT_LOGE_STR("Failed to allocate one GString.");
170 ret = -1;
171 goto end;
172 }
173
174 BT_LIB_LOGD("Initialized error cause: %!+r", cause);
175
176 end:
177 return ret;
178 }
179
180 static
181 int init_component_class_id(
182 struct bt_error_cause_component_class_id *comp_class_id,
183 struct bt_component_class *comp_cls)
184 {
185 int ret = 0;
186
187 BT_ASSERT(comp_class_id);
188 comp_class_id->type = comp_cls->type;
189 comp_class_id->name = g_string_new(comp_cls->name->str);
190 if (!comp_class_id->name) {
191 BT_LOGE_STR("Failed to allocate one GString.");
192 ret = -1;
193 goto end;
194 }
195
196 comp_class_id->plugin_name = g_string_new(comp_cls->plugin_name->str);
197 if (!comp_class_id->plugin_name) {
198 BT_LOGE_STR("Failed to allocate one GString.");
199 ret = -1;
200 goto end;
201 }
202
203 end:
204 return ret;
205 }
206
207 static
208 void set_error_cause_props(struct bt_error_cause *cause,
209 const char *file_name, uint64_t line_no)
210 {
211 BT_ASSERT(cause);
212 g_string_assign(cause->file_name, file_name);
213 cause->line_no = line_no;
214 }
215
216 static
217 struct bt_error_cause *create_error_cause(const char *module_name,
218 const char *file_name, uint64_t line_no)
219 {
220 struct bt_error_cause *cause = g_new0(struct bt_error_cause, 1);
221 int ret;
222
223 BT_LOGD_STR("Creating error cause (unknown actor).");
224
225 if (!cause) {
226 BT_LOGE_STR("Failed to allocate one error cause.");
227 goto error;
228 }
229
230 ret = init_error_cause(cause, BT_ERROR_CAUSE_ACTOR_TYPE_UNKNOWN);
231 if (ret) {
232 goto error;
233 }
234
235 g_string_assign(cause->module_name, module_name);
236 set_error_cause_props(cause, file_name, line_no);
237 BT_LIB_LOGD("Created error cause: %!+r", cause);
238 goto end;
239
240 error:
241 destroy_error_cause(cause);
242 cause = NULL;
243
244 end:
245 return cause;
246 }
247
248 static
249 void append_component_class_id_str(GString *str,
250 struct bt_error_cause_component_class_id *comp_class_id)
251 {
252 const char *type_str = NULL;
253
254 switch (comp_class_id->type) {
255 case BT_COMPONENT_CLASS_TYPE_SOURCE:
256 type_str = "src";
257 break;
258 case BT_COMPONENT_CLASS_TYPE_FILTER:
259 type_str = "flt";
260 break;
261 case BT_COMPONENT_CLASS_TYPE_SINK:
262 type_str = "sink";
263 break;
264 default:
265 abort();
266 }
267
268 if (comp_class_id->plugin_name->len > 0) {
269 g_string_append_printf(str, "%s.%s.%s",
270 type_str, comp_class_id->plugin_name->str,
271 comp_class_id->name->str);
272 } else {
273 g_string_append_printf(str, "%s.%s",
274 type_str, comp_class_id->name->str);
275 }
276 }
277
278 static
279 struct bt_error_cause_component_actor *create_error_cause_component_actor(
280 struct bt_component *comp, const char *file_name,
281 uint64_t line_no)
282 {
283 struct bt_error_cause_component_actor *cause =
284 g_new0(struct bt_error_cause_component_actor, 1);
285 int ret;
286
287 BT_LOGD_STR("Creating error cause object (component actor).");
288
289 if (!cause) {
290 goto error;
291 }
292
293 ret = init_error_cause(&cause->base,
294 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT);
295 if (ret) {
296 goto error;
297 }
298
299 set_error_cause_props(&cause->base, file_name, line_no);
300 cause->comp_name = g_string_new(comp->name->str);
301 if (!cause->comp_name) {
302 BT_LOGE_STR("Failed to allocate one GString.");
303 goto error;
304 }
305
306 ret = init_component_class_id(&cause->comp_class_id, comp->class);
307 if (ret) {
308 goto error;
309 }
310
311 g_string_append_printf(cause->base.module_name, "%s: ",
312 comp->name->str);
313 append_component_class_id_str(cause->base.module_name,
314 &cause->comp_class_id);
315 BT_LIB_LOGD("Created error cause object: %!+r", cause);
316 goto end;
317
318 error:
319 destroy_error_cause(&cause->base);
320 cause = NULL;
321
322 end:
323 return cause;
324 }
325
326 static
327 struct bt_error_cause_component_class_actor *
328 create_error_cause_component_class_actor(struct bt_component_class *comp_cls,
329 const char *file_name, uint64_t line_no)
330 {
331 struct bt_error_cause_component_class_actor *cause =
332 g_new0(struct bt_error_cause_component_class_actor, 1);
333 int ret;
334
335 BT_LOGD_STR("Creating error cause object (component class actor).");
336
337 if (!cause) {
338 BT_LOGE_STR("Failed to allocate one error cause object.");
339 goto error;
340 }
341
342 ret = init_error_cause(&cause->base,
343 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT_CLASS);
344 if (ret) {
345 goto error;
346 }
347
348 set_error_cause_props(&cause->base, file_name, line_no);
349 ret = init_component_class_id(&cause->comp_class_id, comp_cls);
350 if (ret) {
351 goto error;
352 }
353
354 append_component_class_id_str(cause->base.module_name,
355 &cause->comp_class_id);
356 BT_LIB_LOGD("Created error cause object: %!+r", cause);
357 goto end;
358
359 error:
360 destroy_error_cause(&cause->base);
361 cause = NULL;
362
363 end:
364 return cause;
365 }
366
367 struct bt_error_cause_message_iterator_actor *
368 create_error_cause_message_iterator_actor(struct bt_message_iterator *iter,
369 const char *file_name, uint64_t line_no)
370 {
371 struct bt_error_cause_message_iterator_actor *cause;
372 struct bt_self_component_port_input_message_iterator *input_port_iter;
373 int ret;
374
375 BT_LOGD_STR("Creating error cause object (message iterator actor).");
376
377 /*
378 * This can only be created from within a graph, from a user
379 * message iterator, which is a self component port input
380 * message iterator.
381 */
382 BT_ASSERT(iter->type ==
383 BT_MESSAGE_ITERATOR_TYPE_SELF_COMPONENT_PORT_INPUT);
384 input_port_iter = (void *) iter;
385 cause = g_new0(struct bt_error_cause_message_iterator_actor, 1);
386 if (!cause) {
387 BT_LOGE_STR("Failed to allocate one error cause object.");
388 goto error;
389 }
390
391 ret = init_error_cause(&cause->base,
392 BT_ERROR_CAUSE_ACTOR_TYPE_MESSAGE_ITERATOR);
393 if (ret) {
394 goto error;
395 }
396
397 set_error_cause_props(&cause->base, file_name, line_no);
398 cause->comp_name = g_string_new(
399 input_port_iter->upstream_component->name->str);
400 if (!cause->comp_name) {
401 BT_LOGE_STR("Failed to allocate one GString.");
402 goto error;
403 }
404
405 cause->output_port_name = g_string_new(
406 input_port_iter->upstream_port->name->str);
407 if (!cause->output_port_name) {
408 BT_LOGE_STR("Failed to allocate one GString.");
409 goto error;
410 }
411
412 ret = init_component_class_id(&cause->comp_class_id,
413 input_port_iter->upstream_component->class);
414 if (ret) {
415 goto error;
416 }
417
418 g_string_append_printf(cause->base.module_name, "%s (%s): ",
419 input_port_iter->upstream_component->name->str,
420 input_port_iter->upstream_port->name->str);
421 append_component_class_id_str(cause->base.module_name,
422 &cause->comp_class_id);
423 BT_LIB_LOGD("Created error cause object: %!+r", cause);
424 goto end;
425
426 error:
427 destroy_error_cause(&cause->base);
428 cause = NULL;
429
430 end:
431 return cause;
432 }
433
434 BT_HIDDEN
435 struct bt_error *bt_error_create(void)
436 {
437 struct bt_error *error;
438
439 BT_LOGD_STR("Creating error object.");
440 error = g_new0(struct bt_error, 1);
441 if (!error) {
442 BT_LOGE_STR("Failed to allocate one error object.");
443 goto error;
444 }
445
446 error->causes = g_ptr_array_new_with_free_func(
447 (GDestroyNotify) destroy_error_cause);
448 if (!error->causes) {
449 BT_LOGE_STR("Failed to allocate one GPtrArray.");
450 goto error;
451 }
452
453 BT_LOGD("Created error object: addr=%p", error);
454 goto end;
455
456 error:
457 bt_error_destroy(error);
458 error = NULL;
459
460 end:
461 return error;
462 }
463
464 BT_HIDDEN
465 void bt_error_destroy(struct bt_error *error)
466 {
467 if (!error) {
468 goto end;
469 }
470
471 if (error->causes) {
472 g_ptr_array_free(error->causes, TRUE);
473 error->causes = NULL;
474 }
475
476 g_free(error);
477
478 end:
479 return;
480 }
481
482 BT_HIDDEN
483 int bt_error_append_cause_from_unknown(struct bt_error *error,
484 const char *module_name, const char *file_name,
485 uint64_t line_no, const char *msg_fmt, va_list args)
486 {
487 struct bt_error_cause *cause = NULL;
488 int status = BT_FUNC_STATUS_OK;
489
490 BT_ASSERT_PRE_NON_NULL(error, "Error");
491 BT_ASSERT_PRE_NON_NULL(module_name, "Module name");
492 BT_ASSERT_PRE_NON_NULL(file_name, "Function name");
493 BT_ASSERT_PRE_NON_NULL(msg_fmt, "Message format string");
494 BT_LOGD("Appending error cause from unknown actor: "
495 "module-name=\"%s\", func-name=\"%s\", line-no=%" PRIu64,
496 module_name, file_name, line_no);
497 cause = create_error_cause(module_name, file_name, line_no);
498 if (!cause) {
499 /* create_error_cause() logs errors */
500 status = BT_FUNC_STATUS_MEMORY_ERROR;
501 goto end;
502 }
503
504 g_string_append_vprintf(cause->message, msg_fmt, args);
505 g_ptr_array_add(error->causes, cause);
506 BT_LIB_LOGD("Appended error cause: %!+r", cause);
507 cause = NULL;
508
509 end:
510 destroy_error_cause(cause);
511 return status;
512 }
513
514 BT_HIDDEN
515 int bt_error_append_cause_from_component(
516 struct bt_error *error, bt_self_component *self_comp,
517 const char *file_name, uint64_t line_no,
518 const char *msg_fmt, va_list args)
519 {
520 struct bt_error_cause_component_actor *cause = NULL;
521 int status = BT_FUNC_STATUS_OK;
522
523 BT_ASSERT_PRE_NON_NULL(error, "Error");
524 BT_ASSERT_PRE_NON_NULL(self_comp, "Component");
525 BT_ASSERT_PRE_NON_NULL(file_name, "Function name");
526 BT_ASSERT_PRE_NON_NULL(msg_fmt, "Message format string");
527 BT_LIB_LOGD("Appending error cause from component actor: %![comp-]+c",
528 self_comp);
529 cause = create_error_cause_component_actor((void *) self_comp,
530 file_name, line_no);
531 if (!cause) {
532 /* create_error_cause_component_actor() logs errors */
533 status = BT_FUNC_STATUS_MEMORY_ERROR;
534 goto end;
535 }
536
537 g_string_append_vprintf(cause->base.message, msg_fmt, args);
538 g_ptr_array_add(error->causes, cause);
539 BT_LIB_LOGD("Appended error cause: %!+r", cause);
540 cause = NULL;
541
542 end:
543 destroy_error_cause(&cause->base);
544 return status;
545 }
546
547 BT_HIDDEN
548 int bt_error_append_cause_from_component_class(
549 struct bt_error *error,
550 bt_self_component_class *self_comp_class,
551 const char *file_name, uint64_t line_no,
552 const char *msg_fmt, va_list args)
553 {
554 struct bt_error_cause_component_class_actor *cause = NULL;
555 int status = BT_FUNC_STATUS_OK;
556
557 BT_ASSERT_PRE_NON_NULL(error, "Error");
558 BT_ASSERT_PRE_NON_NULL(self_comp_class, "Component class");
559 BT_ASSERT_PRE_NON_NULL(file_name, "Function name");
560 BT_ASSERT_PRE_NON_NULL(msg_fmt, "Message format string");
561 BT_LIB_LOGD("Appending error cause from component class actor: "
562 "%![comp-cls-]+C", self_comp_class);
563 cause = create_error_cause_component_class_actor(
564 (void *) self_comp_class, file_name, line_no);
565 if (!cause) {
566 /* create_error_cause_component_class_actor() logs errors */
567 status = BT_FUNC_STATUS_MEMORY_ERROR;
568 goto end;
569 }
570
571 g_string_append_vprintf(cause->base.message, msg_fmt, args);
572 g_ptr_array_add(error->causes, cause);
573 BT_LIB_LOGD("Appended error cause: %!+r", cause);
574 cause = NULL;
575
576 end:
577 destroy_error_cause(&cause->base);
578 return status;
579 }
580
581 BT_HIDDEN
582 int bt_error_append_cause_from_message_iterator(
583 struct bt_error *error, bt_self_message_iterator *self_iter,
584 const char *file_name, uint64_t line_no,
585 const char *msg_fmt, va_list args)
586 {
587 struct bt_error_cause_message_iterator_actor *cause = NULL;
588 int status = BT_FUNC_STATUS_OK;
589
590 BT_ASSERT_PRE_NON_NULL(error, "Error");
591 BT_ASSERT_PRE_NON_NULL(self_iter, "Message iterator");
592 BT_ASSERT_PRE_NON_NULL(file_name, "Function name");
593 BT_ASSERT_PRE_NON_NULL(msg_fmt, "Message format string");
594 BT_LIB_LOGD("Appending error cause from message iterator actor: "
595 "%![comp-]+i", self_iter);
596 cause = create_error_cause_message_iterator_actor(
597 (void *) self_iter, file_name, line_no);
598 if (!cause) {
599 /* create_error_cause_message_iterator_actor() logs errors */
600 status = BT_FUNC_STATUS_MEMORY_ERROR;
601 goto end;
602 }
603
604 g_string_append_vprintf(cause->base.message, msg_fmt, args);
605 g_ptr_array_add(error->causes, cause);
606 BT_LIB_LOGD("Appended error cause: %!+r", cause);
607 cause = NULL;
608
609 end:
610 destroy_error_cause(&cause->base);
611 return status;
612 }
613
614 static
615 uint64_t error_cause_count(const bt_error *error)
616 {
617 return error->causes ? error->causes->len : 0;
618 }
619
620 uint64_t bt_error_get_cause_count(const bt_error *error)
621 {
622 BT_ASSERT_PRE_NON_NULL(error, "Error");
623 return error_cause_count(error);
624 }
625
626 void bt_error_release(const struct bt_error *error)
627 {
628 BT_ASSERT_PRE_NON_NULL(error, "Error");
629 bt_error_destroy((void *) error);
630 }
631
632 const struct bt_error_cause *bt_error_borrow_cause_by_index(
633 const bt_error *error, uint64_t index)
634 {
635 BT_ASSERT_PRE_NON_NULL(error, "Error");
636 BT_ASSERT_PRE_VALID_INDEX(index, error_cause_count(error));
637 return error->causes->pdata[index];
638 }
639
640 enum bt_error_cause_actor_type bt_error_cause_get_actor_type(
641 const struct bt_error_cause *cause)
642 {
643 BT_ASSERT_PRE_NON_NULL(cause, "Error cause");
644 return cause->actor_type;
645 }
646
647 const char *bt_error_cause_get_message(const struct bt_error_cause *cause)
648 {
649 BT_ASSERT_PRE_NON_NULL(cause, "Error cause");
650 return cause->message->str;
651 }
652
653 const char *bt_error_cause_get_module_name(const struct bt_error_cause *cause)
654 {
655 BT_ASSERT_PRE_NON_NULL(cause, "Error cause");
656 return cause->module_name->str;
657 }
658
659 const char *bt_error_cause_get_file_name(const struct bt_error_cause *cause)
660 {
661 BT_ASSERT_PRE_NON_NULL(cause, "Error cause");
662 return cause->file_name->str;
663 }
664
665 uint64_t bt_error_cause_get_line_number(const bt_error_cause *cause)
666 {
667 BT_ASSERT_PRE_NON_NULL(cause, "Error cause");
668 return cause->line_no;
669 }
670
671 const char *bt_error_cause_component_actor_get_component_name(
672 const struct bt_error_cause *cause)
673 {
674 const struct bt_error_cause_component_actor *spec_cause =
675 (const void *) cause;
676
677 BT_ASSERT_PRE_NON_NULL(cause, "Error cause");
678 BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause,
679 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT);
680 return spec_cause->comp_name->str;
681 }
682
683 bt_component_class_type bt_error_cause_component_actor_get_component_class_type(
684 const struct bt_error_cause *cause)
685 {
686 const struct bt_error_cause_component_actor *spec_cause =
687 (const void *) cause;
688
689 BT_ASSERT_PRE_NON_NULL(cause, "Error cause");
690 BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause,
691 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT);
692 return spec_cause->comp_class_id.type;
693 }
694
695 const char *bt_error_cause_component_actor_get_component_class_name(
696 const struct bt_error_cause *cause)
697 {
698 const struct bt_error_cause_component_actor *spec_cause =
699 (const void *) cause;
700
701 BT_ASSERT_PRE_NON_NULL(cause, "Error cause");
702 BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause,
703 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT);
704 return spec_cause->comp_class_id.name->str;
705 }
706
707 const char *bt_error_cause_component_actor_get_plugin_name(
708 const struct bt_error_cause *cause)
709 {
710 const struct bt_error_cause_component_actor *spec_cause =
711 (const void *) cause;
712
713 BT_ASSERT_PRE_NON_NULL(cause, "Error cause");
714 BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause,
715 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT);
716 return spec_cause->comp_class_id.plugin_name->len > 0 ?
717 spec_cause->comp_class_id.plugin_name->str : NULL;
718 }
719
720 bt_component_class_type
721 bt_error_cause_component_class_actor_get_component_class_type(
722 const struct bt_error_cause *cause)
723 {
724 const struct bt_error_cause_component_class_actor *spec_cause =
725 (const void *) cause;
726
727 BT_ASSERT_PRE_NON_NULL(cause, "Error cause");
728 BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause,
729 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT_CLASS);
730 return spec_cause->comp_class_id.type;
731 }
732
733 const char *bt_error_cause_component_class_actor_get_component_class_name(
734 const struct bt_error_cause *cause)
735 {
736 const struct bt_error_cause_component_class_actor *spec_cause =
737 (const void *) cause;
738
739 BT_ASSERT_PRE_NON_NULL(cause, "Error cause");
740 BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause,
741 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT_CLASS);
742 return spec_cause->comp_class_id.name->str;
743 }
744
745 const char *bt_error_cause_component_class_actor_get_plugin_name(
746 const struct bt_error_cause *cause)
747 {
748 const struct bt_error_cause_component_class_actor *spec_cause =
749 (const void *) cause;
750
751 BT_ASSERT_PRE_NON_NULL(cause, "Error cause");
752 BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause,
753 BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT_CLASS);
754 return spec_cause->comp_class_id.plugin_name->len > 0 ?
755 spec_cause->comp_class_id.plugin_name->str : NULL;
756 }
757
758 const char *bt_error_cause_message_iterator_actor_get_component_name(
759 const struct bt_error_cause *cause)
760 {
761 const struct bt_error_cause_message_iterator_actor *spec_cause =
762 (const void *) cause;
763
764 BT_ASSERT_PRE_NON_NULL(cause, "Error cause");
765 BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause,
766 BT_ERROR_CAUSE_ACTOR_TYPE_MESSAGE_ITERATOR);
767 return spec_cause->comp_name->str;
768 }
769
770 const char *
771 bt_error_cause_message_iterator_actor_get_component_output_port_name(
772 const struct bt_error_cause *cause)
773 {
774 const struct bt_error_cause_message_iterator_actor *spec_cause =
775 (const void *) cause;
776
777 BT_ASSERT_PRE_NON_NULL(cause, "Error cause");
778 BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause,
779 BT_ERROR_CAUSE_ACTOR_TYPE_MESSAGE_ITERATOR);
780 return spec_cause->output_port_name->str;
781 }
782
783 bt_component_class_type
784 bt_error_cause_message_iterator_actor_get_component_class_type(
785 const struct bt_error_cause *cause)
786 {
787 const struct bt_error_cause_message_iterator_actor *spec_cause =
788 (const void *) cause;
789
790 BT_ASSERT_PRE_NON_NULL(cause, "Error cause");
791 BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause,
792 BT_ERROR_CAUSE_ACTOR_TYPE_MESSAGE_ITERATOR);
793 return spec_cause->comp_class_id.type;
794 }
795
796 const char *bt_error_cause_message_iterator_actor_get_component_class_name(
797 const struct bt_error_cause *cause)
798 {
799 const struct bt_error_cause_message_iterator_actor *spec_cause =
800 (const void *) cause;
801
802 BT_ASSERT_PRE_NON_NULL(cause, "Error cause");
803 BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause,
804 BT_ERROR_CAUSE_ACTOR_TYPE_MESSAGE_ITERATOR);
805 return spec_cause->comp_class_id.name->str;
806 }
807
808 const char *bt_error_cause_message_iterator_actor_get_plugin_name(
809 const struct bt_error_cause *cause)
810 {
811 const struct bt_error_cause_message_iterator_actor *spec_cause =
812 (const void *) cause;
813
814 BT_ASSERT_PRE_NON_NULL(cause, "Error cause");
815 BT_ASSERT_PRE_CAUSE_HAS_ACTOR_TYPE(cause,
816 BT_ERROR_CAUSE_ACTOR_TYPE_MESSAGE_ITERATOR);
817 return spec_cause->comp_class_id.plugin_name->len > 0 ?
818 spec_cause->comp_class_id.plugin_name->str : NULL;
819 }
This page took 0.046111 seconds and 4 git commands to generate.