src/lib/graph/component-class.c

   1 /*
   2  * Copyright 2017-2018 Philippe Proulx <pproulx@efficios.com>
   3  * Copyright 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy
   6  * of this software and associated documentation files (the "Software"), to deal
   7  * in the Software without restriction, including without limitation the rights
   8  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9  * copies of the Software, and to permit persons to whom the Software is
  10  * furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21  * SOFTWARE.
  22  */
  23
  24 #define BT_LOG_TAG "LIB/COMPONENT-CLASS"
  25 #include "lib/logging.h"
  26
  27 #include "common/assert.h"
  28 #include "lib/assert-pre.h"
  29 #include "compat/compiler.h"
  30 #include <babeltrace2/graph/component-class.h>
  31 #include <babeltrace2/graph/component-class-const.h>
  32 #include <babeltrace2/graph/component-class-source.h>
  33 #include <babeltrace2/graph/component-class-source-const.h>
  34 #include <babeltrace2/graph/component-class-filter.h>
  35 #include <babeltrace2/graph/component-class-filter-const.h>
  36 #include <babeltrace2/graph/component-class-sink.h>
  37 #include <babeltrace2/graph/component-class-sink-const.h>
  38 #include <babeltrace2/types.h>
  39 #include <glib.h>
  40
  41 #include "component-class.h"
  42 #include "lib/func-status.h"
  43
  44 #define BT_ASSERT_PRE_COMP_CLS_HOT(_cc) \
  45         BT_ASSERT_PRE_HOT(((const struct bt_component_class *) (_cc)),  \
  46                 "Component class", ": %!+C", (_cc))
  47
  48 static
  49 void destroy_component_class(struct bt_object *obj)
  50 {
  51         struct bt_component_class *class;
  52         int i;
  53
  54         BT_ASSERT(obj);
  55         class = container_of(obj, struct bt_component_class, base);
  56
  57         BT_LIB_LOGI("Destroying component class: %!+C", class);
  58
  59         /* Call destroy listeners in reverse registration order */
  60         for (i = class->destroy_listeners->len - 1; i >= 0; i--) {
  61                 struct bt_component_class_destroy_listener *listener =
  62                         &g_array_index(class->destroy_listeners,
  63                                 struct bt_component_class_destroy_listener,
  64                                 i);
  65
  66                 BT_LOGD("Calling destroy listener: func-addr=%p, data-addr=%p",
  67                         listener->func, listener->data);
  68                 listener->func(class, listener->data);
  69         }
  70
  71         if (class->name) {
  72                 g_string_free(class->name, TRUE);
  73                 class->name = NULL;
  74         }
  75
  76         if (class->description) {
  77                 g_string_free(class->description, TRUE);
  78                 class->description = NULL;
  79         }
  80
  81         if (class->help) {
  82                 g_string_free(class->help, TRUE);
  83                 class->help = NULL;
  84         }
  85
  86         if (class->destroy_listeners) {
  87                 g_array_free(class->destroy_listeners, TRUE);
  88                 class->destroy_listeners = NULL;
  89         }
  90
  91         g_free(class);
  92 }
  93
  94 static
  95 int bt_component_class_init(struct bt_component_class *class,
  96                 enum bt_component_class_type type, const char *name)
  97 {
  98         int ret = 0;
  99
 100         bt_object_init_shared(&class->base, destroy_component_class);
 101         class->type = type;
 102         class->name = g_string_new(name);
 103         if (!class->name) {
 104                 BT_LOGE_STR("Failed to allocate a GString.");
 105                 goto error;
 106         }
 107
 108         class->description = g_string_new(NULL);
 109         if (!class->description) {
 110                 BT_LOGE_STR("Failed to allocate a GString.");
 111                 goto error;
 112         }
 113
 114         class->help = g_string_new(NULL);
 115         if (!class->help) {
 116                 BT_LOGE_STR("Failed to allocate a GString.");
 117                 goto error;
 118         }
 119
 120         class->destroy_listeners = g_array_new(FALSE, TRUE,
 121                 sizeof(struct bt_component_class_destroy_listener));
 122         if (!class->destroy_listeners) {
 123                 BT_LOGE_STR("Failed to allocate a GArray.");
 124                 goto error;
 125         }
 126
 127         goto end;
 128
 129 error:
 130         BT_OBJECT_PUT_REF_AND_RESET(class);
 131         ret = -1;
 132
 133 end:
 134         return ret;
 135 }
 136
 137 struct bt_component_class_source *bt_component_class_source_create(
 138                 const char *name,
 139                 bt_component_class_source_message_iterator_next_method method)
 140 {
 141         struct bt_component_class_source *source_class = NULL;
 142         int ret;
 143
 144         BT_ASSERT_PRE_NON_NULL(name, "Name");
 145         BT_ASSERT_PRE_NON_NULL(method, "Message iterator next method");
 146         BT_LOGI("Creating source component class: "
 147                 "name=\"%s\", msg-iter-next-method-addr=%p",
 148                 name, method);
 149         source_class = g_new0(struct bt_component_class_source, 1);
 150         if (!source_class) {
 151                 BT_LOGE_STR("Failed to allocate one source component class.");
 152                 goto end;
 153         }
 154
 155         /* bt_component_class_init() logs errors */
 156         ret = bt_component_class_init(&source_class->parent,
 157                 BT_COMPONENT_CLASS_TYPE_SOURCE, name);
 158         if (ret) {
 159                 /*
 160                  * If bt_component_class_init() fails, the component
 161                  * class is put, therefore its memory is already
 162                  * freed.
 163                  */
 164                 source_class = NULL;
 165                 goto end;
 166         }
 167
 168         source_class->methods.msg_iter_next = method;
 169         BT_LIB_LOGI("Created source component class: %!+C", source_class);
 170
 171 end:
 172         return (void *) source_class;
 173 }
 174
 175 struct bt_component_class_filter *bt_component_class_filter_create(
 176                 const char *name,
 177                 bt_component_class_filter_message_iterator_next_method method)
 178 {
 179         struct bt_component_class_filter *filter_class = NULL;
 180         int ret;
 181
 182         BT_ASSERT_PRE_NON_NULL(name, "Name");
 183         BT_ASSERT_PRE_NON_NULL(method, "Message iterator next method");
 184         BT_LOGI("Creating filter component class: "
 185                 "name=\"%s\", msg-iter-next-method-addr=%p",
 186                 name, method);
 187         filter_class = g_new0(struct bt_component_class_filter, 1);
 188         if (!filter_class) {
 189                 BT_LOGE_STR("Failed to allocate one filter component class.");
 190                 goto end;
 191         }
 192
 193         /* bt_component_class_init() logs errors */
 194         ret = bt_component_class_init(&filter_class->parent,
 195                 BT_COMPONENT_CLASS_TYPE_FILTER, name);
 196         if (ret) {
 197                 /*
 198                  * If bt_component_class_init() fails, the component
 199                  * class is put, therefore its memory is already
 200                  * freed.
 201                  */
 202                 filter_class = NULL;
 203                 goto end;
 204         }
 205
 206         filter_class->methods.msg_iter_next = method;
 207         BT_LIB_LOGI("Created filter component class: %!+C", filter_class);
 208
 209 end:
 210         return (void *) filter_class;
 211 }
 212
 213 struct bt_component_class_sink *bt_component_class_sink_create(
 214                 const char *name, bt_component_class_sink_consume_method method)
 215 {
 216         struct bt_component_class_sink *sink_class = NULL;
 217         int ret;
 218
 219         BT_ASSERT_PRE_NON_NULL(name, "Name");
 220         BT_ASSERT_PRE_NON_NULL(method, "Consume next method");
 221         BT_LOGI("Creating sink component class: "
 222                 "name=\"%s\", consume-method-addr=%p",
 223                 name, method);
 224         sink_class = g_new0(struct bt_component_class_sink, 1);
 225         if (!sink_class) {
 226                 BT_LOGE_STR("Failed to allocate one sink component class.");
 227                 goto end;
 228         }
 229
 230         /* bt_component_class_init() logs errors */
 231         ret = bt_component_class_init(&sink_class->parent,
 232                 BT_COMPONENT_CLASS_TYPE_SINK, name);
 233         if (ret) {
 234                 /*
 235                  * If bt_component_class_init() fails, the component
 236                  * class is put, therefore its memory is already
 237                  * freed.
 238                  */
 239                 sink_class = NULL;
 240                 goto end;
 241         }
 242
 243         sink_class->methods.consume = method;
 244         BT_LIB_LOGI("Created sink component class: %!+C", sink_class);
 245
 246 end:
 247         return (void *) sink_class;
 248 }
 249
 250 enum bt_component_class_set_method_status
 251 bt_component_class_source_set_init_method(
 252                 struct bt_component_class_source *comp_cls,
 253                 bt_component_class_source_init_method method)
 254 {
 255         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 256         BT_ASSERT_PRE_NON_NULL(method, "Method");
 257         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 258         comp_cls->methods.init = method;
 259         BT_LIB_LOGD("Set source component class's initialization method: "
 260                 "%!+C", comp_cls);
 261         return BT_FUNC_STATUS_OK;
 262 }
 263
 264 enum bt_component_class_set_method_status
 265 bt_component_class_filter_set_init_method(
 266                 struct bt_component_class_filter *comp_cls,
 267                 bt_component_class_filter_init_method method)
 268 {
 269         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 270         BT_ASSERT_PRE_NON_NULL(method, "Method");
 271         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 272         comp_cls->methods.init = method;
 273         BT_LIB_LOGD("Set filter component class's initialization method: "
 274                 "%!+C", comp_cls);
 275         return BT_FUNC_STATUS_OK;
 276 }
 277
 278 enum bt_component_class_set_method_status
 279 bt_component_class_sink_set_init_method(
 280                 struct bt_component_class_sink *comp_cls,
 281                 bt_component_class_sink_init_method method)
 282 {
 283         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 284         BT_ASSERT_PRE_NON_NULL(method, "Method");
 285         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 286         comp_cls->methods.init = method;
 287         BT_LIB_LOGD("Set sink component class's initialization method: "
 288                 "%!+C", comp_cls);
 289         return BT_FUNC_STATUS_OK;
 290 }
 291
 292 enum bt_component_class_set_method_status
 293 bt_component_class_source_set_finalize_method(
 294                 struct bt_component_class_source *comp_cls,
 295                 bt_component_class_source_finalize_method method)
 296 {
 297         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 298         BT_ASSERT_PRE_NON_NULL(method, "Method");
 299         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 300         comp_cls->methods.finalize = method;
 301         BT_LIB_LOGD("Set source component class's finalization method: "
 302                 "%!+C", comp_cls);
 303         return BT_FUNC_STATUS_OK;
 304 }
 305
 306 enum bt_component_class_set_method_status
 307 bt_component_class_filter_set_finalize_method(
 308                 struct bt_component_class_filter *comp_cls,
 309                 bt_component_class_filter_finalize_method method)
 310 {
 311         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 312         BT_ASSERT_PRE_NON_NULL(method, "Method");
 313         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 314         comp_cls->methods.finalize = method;
 315         BT_LIB_LOGD("Set filter component class's finalization method: "
 316                 "%!+C", comp_cls);
 317         return BT_FUNC_STATUS_OK;
 318 }
 319
 320 enum bt_component_class_set_method_status
 321 bt_component_class_sink_set_finalize_method(
 322                 struct bt_component_class_sink *comp_cls,
 323                 bt_component_class_sink_finalize_method method)
 324 {
 325         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 326         BT_ASSERT_PRE_NON_NULL(method, "Method");
 327         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 328         comp_cls->methods.finalize = method;
 329         BT_LIB_LOGD("Set sink component class's finalization method: "
 330                 "%!+C", comp_cls);
 331         return BT_FUNC_STATUS_OK;
 332 }
 333
 334 enum bt_component_class_set_method_status
 335 bt_component_class_source_set_query_method(
 336                 struct bt_component_class_source *comp_cls,
 337                 bt_component_class_source_query_method method)
 338 {
 339         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 340         BT_ASSERT_PRE_NON_NULL(method, "Method");
 341         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 342         comp_cls->methods.query = method;
 343         BT_LIB_LOGD("Set source component class's query method: "
 344                 "%!+C", comp_cls);
 345         return BT_FUNC_STATUS_OK;
 346 }
 347
 348 enum bt_component_class_set_method_status
 349 bt_component_class_filter_set_query_method(
 350                 struct bt_component_class_filter *comp_cls,
 351                 bt_component_class_filter_query_method method)
 352 {
 353         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 354         BT_ASSERT_PRE_NON_NULL(method, "Method");
 355         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 356         comp_cls->methods.query = method;
 357         BT_LIB_LOGD("Set filter component class's query method: "
 358                 "%!+C", comp_cls);
 359         return BT_FUNC_STATUS_OK;
 360 }
 361
 362 enum bt_component_class_set_method_status
 363 bt_component_class_sink_set_query_method(
 364                 struct bt_component_class_sink *comp_cls,
 365                 bt_component_class_sink_query_method method)
 366 {
 367         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 368         BT_ASSERT_PRE_NON_NULL(method, "Method");
 369         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 370         comp_cls->methods.query = method;
 371         BT_LIB_LOGD("Set sink component class's query method: "
 372                 "%!+C", comp_cls);
 373         return BT_FUNC_STATUS_OK;
 374 }
 375
 376 enum bt_component_class_set_method_status
 377 bt_component_class_filter_set_input_port_connected_method(
 378                 struct bt_component_class_filter *comp_cls,
 379                 bt_component_class_filter_input_port_connected_method method)
 380 {
 381         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 382         BT_ASSERT_PRE_NON_NULL(method, "Method");
 383         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 384         comp_cls->methods.input_port_connected = method;
 385         BT_LIB_LOGD("Set filter component class's \"input port connected\" method"
 386                 ": %!+C", comp_cls);
 387         return BT_FUNC_STATUS_OK;
 388 }
 389
 390 enum bt_component_class_set_method_status
 391 bt_component_class_sink_set_input_port_connected_method(
 392                 struct bt_component_class_sink *comp_cls,
 393                 bt_component_class_sink_input_port_connected_method method)
 394 {
 395         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 396         BT_ASSERT_PRE_NON_NULL(method, "Method");
 397         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 398         comp_cls->methods.input_port_connected = method;
 399         BT_LIB_LOGD("Set sink component class's \"input port connected\" method"
 400                 ": %!+C", comp_cls);
 401         return BT_FUNC_STATUS_OK;
 402 }
 403
 404 enum bt_component_class_set_method_status
 405 bt_component_class_source_set_output_port_connected_method(
 406                 struct bt_component_class_source *comp_cls,
 407                 bt_component_class_source_output_port_connected_method method)
 408 {
 409         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 410         BT_ASSERT_PRE_NON_NULL(method, "Method");
 411         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 412         comp_cls->methods.output_port_connected = method;
 413         BT_LIB_LOGD("Set source component class's \"output port connected\" method"
 414                 ": %!+C", comp_cls);
 415         return BT_FUNC_STATUS_OK;
 416 }
 417
 418 enum bt_component_class_set_method_status
 419 bt_component_class_filter_set_output_port_connected_method(
 420                 struct bt_component_class_filter *comp_cls,
 421                 bt_component_class_filter_output_port_connected_method method)
 422 {
 423         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 424         BT_ASSERT_PRE_NON_NULL(method, "Method");
 425         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 426         comp_cls->methods.output_port_connected = method;
 427         BT_LIB_LOGD("Set filter component class's \"output port connected\" method"
 428                 ": %!+C", comp_cls);
 429         return BT_FUNC_STATUS_OK;
 430 }
 431
 432 enum bt_component_class_set_method_status
 433 bt_component_class_sink_set_graph_is_configured_method(
 434                 struct bt_component_class_sink *comp_cls,
 435                 bt_component_class_sink_graph_is_configured_method method)
 436 {
 437         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 438         BT_ASSERT_PRE_NON_NULL(method, "Method");
 439         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 440         comp_cls->methods.graph_is_configured = method;
 441         BT_LIB_LOGD("Set sink component class's \"graph is configured\" method"
 442                 ": %!+C", comp_cls);
 443         return BT_FUNC_STATUS_OK;
 444 }
 445
 446 enum bt_component_class_set_method_status
 447 bt_component_class_source_set_message_iterator_init_method(
 448                 struct bt_component_class_source *comp_cls,
 449                 bt_component_class_source_message_iterator_init_method method)
 450 {
 451         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 452         BT_ASSERT_PRE_NON_NULL(method, "Method");
 453         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 454         comp_cls->methods.msg_iter_init = method;
 455         BT_LIB_LOGD("Set source component class's message iterator initialization method"
 456                 ": %!+C", comp_cls);
 457         return BT_FUNC_STATUS_OK;
 458 }
 459
 460 enum bt_component_class_set_method_status
 461 bt_component_class_filter_set_message_iterator_init_method(
 462                 struct bt_component_class_filter *comp_cls,
 463                 bt_component_class_filter_message_iterator_init_method method)
 464 {
 465         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 466         BT_ASSERT_PRE_NON_NULL(method, "Method");
 467         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 468         comp_cls->methods.msg_iter_init = method;
 469         BT_LIB_LOGD("Set filter component class's message iterator initialization method"
 470                 ": %!+C", comp_cls);
 471         return BT_FUNC_STATUS_OK;
 472 }
 473
 474 enum bt_component_class_set_method_status
 475 bt_component_class_source_set_message_iterator_finalize_method(
 476                 struct bt_component_class_source *comp_cls,
 477                 bt_component_class_source_message_iterator_finalize_method method)
 478 {
 479         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 480         BT_ASSERT_PRE_NON_NULL(method, "Method");
 481         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 482         comp_cls->methods.msg_iter_finalize = method;
 483         BT_LIB_LOGD("Set source component class's message iterator finalization method"
 484                 ": %!+C", comp_cls);
 485         return BT_FUNC_STATUS_OK;
 486 }
 487
 488 enum bt_component_class_set_method_status
 489 bt_component_class_filter_set_message_iterator_finalize_method(
 490                 struct bt_component_class_filter *comp_cls,
 491                 bt_component_class_filter_message_iterator_finalize_method method)
 492 {
 493         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 494         BT_ASSERT_PRE_NON_NULL(method, "Method");
 495         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 496         comp_cls->methods.msg_iter_finalize = method;
 497         BT_LIB_LOGD("Set filter component class's message iterator finalization method"
 498                 ": %!+C", comp_cls);
 499         return BT_FUNC_STATUS_OK;
 500 }
 501
 502 enum bt_component_class_set_method_status
 503 bt_component_class_filter_set_message_iterator_seek_ns_from_origin_method(
 504                 struct bt_component_class_filter *comp_cls,
 505                 bt_component_class_filter_message_iterator_seek_ns_from_origin_method method)
 506 {
 507         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 508         BT_ASSERT_PRE_NON_NULL(method, "Method");
 509         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 510         comp_cls->methods.msg_iter_seek_ns_from_origin = method;
 511         BT_LIB_LOGD("Set filter component class's message iterator \"seek nanoseconds from origin\" method"
 512                 ": %!+C", comp_cls);
 513         return BT_FUNC_STATUS_OK;
 514 }
 515
 516 enum bt_component_class_set_method_status
 517 bt_component_class_source_set_message_iterator_seek_ns_from_origin_method(
 518                 struct bt_component_class_source *comp_cls,
 519                 bt_component_class_source_message_iterator_seek_ns_from_origin_method method)
 520 {
 521         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 522         BT_ASSERT_PRE_NON_NULL(method, "Method");
 523         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 524         comp_cls->methods.msg_iter_seek_ns_from_origin = method;
 525         BT_LIB_LOGD("Set source component class's message iterator \"seek nanoseconds from origin\" method"
 526                 ": %!+C", comp_cls);
 527         return BT_FUNC_STATUS_OK;
 528 }
 529
 530 enum bt_component_class_set_method_status
 531 bt_component_class_filter_set_message_iterator_seek_beginning_method(
 532                 struct bt_component_class_filter *comp_cls,
 533                 bt_component_class_filter_message_iterator_seek_beginning_method method)
 534 {
 535         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 536         BT_ASSERT_PRE_NON_NULL(method, "Method");
 537         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 538         comp_cls->methods.msg_iter_seek_beginning = method;
 539         BT_LIB_LOGD("Set filter component class's message iterator \"seek beginning\" method"
 540                 ": %!+C", comp_cls);
 541         return BT_FUNC_STATUS_OK;
 542 }
 543
 544 enum bt_component_class_set_method_status
 545 bt_component_class_source_set_message_iterator_seek_beginning_method(
 546                 struct bt_component_class_source *comp_cls,
 547                 bt_component_class_source_message_iterator_seek_beginning_method method)
 548 {
 549         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 550         BT_ASSERT_PRE_NON_NULL(method, "Method");
 551         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 552         comp_cls->methods.msg_iter_seek_beginning = method;
 553         BT_LIB_LOGD("Set source component class's message iterator \"seek beginning\" method"
 554                 ": %!+C", comp_cls);
 555         return BT_FUNC_STATUS_OK;
 556 }
 557
 558 enum bt_component_class_set_method_status
 559 bt_component_class_filter_set_message_iterator_can_seek_beginning_method(
 560                 struct bt_component_class_filter *comp_cls,
 561                 bt_component_class_filter_message_iterator_can_seek_beginning_method method)
 562 {
 563         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 564         BT_ASSERT_PRE_NON_NULL(method, "Method");
 565         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 566         comp_cls->methods.msg_iter_can_seek_beginning = method;
 567         BT_LIB_LOGD("Set filter component class's message iterator \"can seek beginning\" method"
 568                 ": %!+C", comp_cls);
 569         return BT_FUNC_STATUS_OK;
 570 }
 571
 572 enum bt_component_class_set_method_status
 573 bt_component_class_source_set_message_iterator_can_seek_beginning_method(
 574                 struct bt_component_class_source *comp_cls,
 575                 bt_component_class_source_message_iterator_can_seek_beginning_method method)
 576 {
 577         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 578         BT_ASSERT_PRE_NON_NULL(method, "Method");
 579         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 580         comp_cls->methods.msg_iter_can_seek_beginning = method;
 581         BT_LIB_LOGD("Set source component class's message iterator \"can seek beginning\" method"
 582                 ": %!+C", comp_cls);
 583         return BT_FUNC_STATUS_OK;
 584 }
 585
 586 enum bt_component_class_set_method_status
 587 bt_component_class_filter_set_message_iterator_can_seek_ns_from_origin_method(
 588                 struct bt_component_class_filter *comp_cls,
 589                 bt_component_class_filter_message_iterator_can_seek_ns_from_origin_method method)
 590 {
 591         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 592         BT_ASSERT_PRE_NON_NULL(method, "Method");
 593         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 594         comp_cls->methods.msg_iter_can_seek_ns_from_origin = method;
 595         BT_LIB_LOGD("Set filter component class's message iterator \"can seek nanoseconds from origin\" method"
 596                 ": %!+C", comp_cls);
 597         return BT_FUNC_STATUS_OK;
 598 }
 599
 600 enum bt_component_class_set_method_status
 601 bt_component_class_source_set_message_iterator_can_seek_ns_from_origin_method(
 602                 struct bt_component_class_source *comp_cls,
 603                 bt_component_class_source_message_iterator_can_seek_ns_from_origin_method method)
 604 {
 605         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 606         BT_ASSERT_PRE_NON_NULL(method, "Method");
 607         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 608         comp_cls->methods.msg_iter_can_seek_ns_from_origin = method;
 609         BT_LIB_LOGD("Set source component class's message iterator \"can seek nanoseconds from origin\" method"
 610                 ": %!+C", comp_cls);
 611         return BT_FUNC_STATUS_OK;
 612 }
 613
 614 enum bt_component_class_set_description_status
 615 bt_component_class_set_description(
 616                 struct bt_component_class *comp_cls,
 617                 const char *description)
 618 {
 619         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 620         BT_ASSERT_PRE_NON_NULL(description, "Description");
 621         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 622         g_string_assign(comp_cls->description, description);
 623         BT_LIB_LOGD("Set component class's description: "
 624                 "addr=%p, name=\"%s\", type=%s",
 625                 comp_cls,
 626                 bt_component_class_get_name(comp_cls),
 627                 bt_component_class_type_string(comp_cls->type));
 628         return BT_FUNC_STATUS_OK;
 629 }
 630
 631 enum bt_component_class_set_help_status bt_component_class_set_help(
 632                 struct bt_component_class *comp_cls,
 633                 const char *help)
 634 {
 635         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 636         BT_ASSERT_PRE_NON_NULL(help, "Help");
 637         BT_ASSERT_PRE_COMP_CLS_HOT(comp_cls);
 638         g_string_assign(comp_cls->help, help);
 639         BT_LIB_LOGD("Set component class's help text: %!+C", comp_cls);
 640         return BT_FUNC_STATUS_OK;
 641 }
 642
 643 const char *bt_component_class_get_name(const struct bt_component_class *comp_cls)
 644 {
 645         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 646         return comp_cls->name->str;
 647 }
 648
 649 enum bt_component_class_type bt_component_class_get_type(
 650                 const struct bt_component_class *comp_cls)
 651 {
 652         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 653         return comp_cls->type;
 654 }
 655
 656 const char *bt_component_class_get_description(
 657                 const struct bt_component_class *comp_cls)
 658 {
 659         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 660         return comp_cls->description &&
 661                 comp_cls->description->str[0] != '\0' ?
 662                 comp_cls->description->str : NULL;
 663 }
 664
 665 const char *bt_component_class_get_help(
 666                 const struct bt_component_class *comp_cls)
 667 {
 668         BT_ASSERT_PRE_NON_NULL(comp_cls, "Component class");
 669         return comp_cls->help &&
 670                 comp_cls->help->str[0] != '\0' ? comp_cls->help->str : NULL;
 671 }
 672
 673 BT_HIDDEN
 674 void bt_component_class_add_destroy_listener(
 675                 struct bt_component_class *comp_cls,
 676                 bt_component_class_destroy_listener_func func, void *data)
 677 {
 678         struct bt_component_class_destroy_listener listener;
 679
 680         BT_ASSERT(comp_cls);
 681         BT_ASSERT(func);
 682         listener.func = func;
 683         listener.data = data;
 684         g_array_append_val(comp_cls->destroy_listeners, listener);
 685         BT_LIB_LOGD("Added destroy listener to component class: "
 686                 "%![cc-]+C, listener-func-addr=%p", comp_cls, func);
 687 }
 688
 689 BT_HIDDEN
 690 void _bt_component_class_freeze(const struct bt_component_class *comp_cls)
 691 {
 692         BT_ASSERT(comp_cls);
 693         BT_LIB_LOGD("Freezing component class: %!+C", comp_cls);
 694         ((struct bt_component_class *) comp_cls)->frozen = true;
 695 }
 696
 697 void bt_component_class_get_ref(
 698                 const struct bt_component_class *component_class)
 699 {
 700         bt_object_get_ref(component_class);
 701 }
 702
 703 void bt_component_class_put_ref(
 704                 const struct bt_component_class *component_class)
 705 {
 706         bt_object_put_ref(component_class);
 707 }
 708
 709 void bt_component_class_source_get_ref(
 710                 const struct bt_component_class_source *component_class_source)
 711 {
 712         bt_object_get_ref(component_class_source);
 713 }
 714
 715 void bt_component_class_source_put_ref(
 716                 const struct bt_component_class_source *component_class_source)
 717 {
 718         bt_object_put_ref(component_class_source);
 719 }
 720
 721 void bt_component_class_filter_get_ref(
 722                 const struct bt_component_class_filter *component_class_filter)
 723 {
 724         bt_object_get_ref(component_class_filter);
 725 }
 726
 727 void bt_component_class_filter_put_ref(
 728                 const struct bt_component_class_filter *component_class_filter)
 729 {
 730         bt_object_put_ref(component_class_filter);
 731 }
 732
 733 void bt_component_class_sink_get_ref(
 734                 const struct bt_component_class_sink *component_class_sink)
 735 {
 736         bt_object_get_ref(component_class_sink);
 737 }
 738
 739 void bt_component_class_sink_put_ref(
 740                 const struct bt_component_class_sink *component_class_sink)
 741 {
 742         bt_object_put_ref(component_class_sink);
 743 }