lib/graph/component-class.c

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