#include <babeltrace/graph/port.h>
#include <babeltrace/graph/graph-internal.h>
#include <babeltrace/types.h>
+#include <babeltrace/assert-internal.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdlib.h>
struct discarded_elements_state {
- struct bt_ctf_clock_value *cur_begin;
+ struct bt_clock_value *cur_begin;
uint64_t cur_count;
};
struct stream_state {
- struct bt_ctf_stream *stream; /* owned by this */
- struct bt_ctf_packet *cur_packet; /* owned by this */
+ struct bt_stream *stream; /* owned by this */
+ struct bt_packet *cur_packet; /* owned by this */
struct discarded_elements_state discarded_packets_state;
struct discarded_elements_state discarded_events_state;
bt_bool is_ended;
/* ACTION_TYPE_MAP_PORT_TO_COMP_IN_STREAM */
struct {
- struct bt_ctf_stream *stream; /* owned by this */
+ struct bt_stream *stream; /* owned by this */
struct bt_component *component; /* owned by this */
struct bt_port *port; /* owned by this */
} map_port_to_comp_in_stream;
/* ACTION_TYPE_ADD_STREAM_STATE */
struct {
- struct bt_ctf_stream *stream; /* owned by this */
+ struct bt_stream *stream; /* owned by this */
struct stream_state *stream_state; /* owned by this */
} add_stream_state;
/* ACTION_TYPE_SET_STREAM_STATE_CUR_PACKET */
struct {
struct stream_state *stream_state; /* weak */
- struct bt_ctf_packet *packet; /* owned by this */
+ struct bt_packet *packet; /* owned by this */
} set_stream_state_cur_packet;
/* ACTION_TYPE_UPDATE_STREAM_STATE_DISCARDED_PACKETS */
/* ACTION_TYPE_UPDATE_STREAM_STATE_DISCARDED_EVENTS */
struct {
struct stream_state *stream_state; /* weak */
- struct bt_ctf_clock_value *cur_begin; /* owned by this */
+ struct bt_clock_value *cur_begin; /* owned by this */
uint64_t cur_count;
} update_stream_state_discarded_elements;
} payload;
};
static
-void stream_destroy_listener(struct bt_ctf_stream *stream, void *data)
+void stream_destroy_listener(struct bt_stream *stream, void *data)
{
struct bt_notification_iterator_private_connection *iterator = data;
static
void destroy_action(struct action *action)
{
- assert(action);
+ BT_ASSERT(action);
switch (action->type) {
case ACTION_TYPE_PUSH_NOTIF:
action->payload.push_notif.notif = NULL;
break;
case ACTION_TYPE_MAP_PORT_TO_COMP_IN_STREAM:
- bt_ctf_stream_map_component_to_port(
+ bt_stream_map_component_to_port(
action->payload.map_port_to_comp_in_stream.stream,
action->payload.map_port_to_comp_in_stream.component,
action->payload.map_port_to_comp_in_stream.port);
* could be reused for another stream, and they
* must have different states.
*/
- bt_ctf_stream_add_destroy_listener(
+ bt_stream_add_destroy_listener(
action->payload.set_stream_state_is_ended.stream_state->stream,
stream_destroy_listener, iterator);
action->payload.set_stream_state_is_ended.stream_state->is_ended = BT_TRUE;
}
static
-struct stream_state *create_stream_state(struct bt_ctf_stream *stream)
+struct stream_state *create_stream_state(struct bt_stream *stream)
{
struct stream_state *stream_state = g_new0(struct stream_state, 1);
stream_state->stream = bt_get(stream);
BT_LOGV("Created stream state: stream-addr=%p, stream-name=\"%s\", "
"stream-state-addr=%p",
- stream, bt_ctf_stream_get_name(stream), stream_state);
+ stream, bt_stream_get_name(stream), stream_state);
end:
return stream_state;
{
struct bt_notification_iterator_private_connection *iterator;
- assert(obj);
+ BT_ASSERT(obj);
/*
* The notification iterator's reference count is 0 if we're
g_hash_table_iter_init(&ht_iter, iterator->stream_states);
while (g_hash_table_iter_next(&ht_iter, &stream_gptr, &stream_state_gptr)) {
- assert(stream_gptr);
+ BT_ASSERT(stream_gptr);
BT_LOGD_STR("Removing stream's destroy listener for notification iterator.");
- bt_ctf_stream_remove_destroy_listener(
+ bt_stream_remove_destroy_listener(
(void *) stream_gptr, stream_destroy_listener,
iterator);
}
bt_component_class_notification_iterator_finalize_method
finalize_method = NULL;
- assert(iterator);
+ BT_ASSERT(iterator);
switch (iterator->state) {
case BT_PRIVATE_CONNECTION_NOTIFICATION_ITERATOR_STATE_NON_INITIALIZED:
iterator->state = BT_PRIVATE_CONNECTION_NOTIFICATION_ITERATOR_STATE_FINALIZED;
}
- assert(iterator->upstream_component);
+ BT_ASSERT(iterator->upstream_component);
comp_class = iterator->upstream_component->class;
/* Call user-defined destroy method */
struct bt_notification_iterator_private_connection *iterator,
struct bt_connection *connection)
{
- assert(iterator);
+ BT_ASSERT(iterator);
iterator->connection = connection;
BT_LOGV("Set notification iterator's connection: "
"iter-addr=%p, conn-addr=%p", iterator, connection);
const enum bt_notification_type *notif_type;
int ret = 0;
- assert(notif_types);
+ BT_ASSERT(notif_types);
iterator->subscription_mask = 0;
for (notif_type = notif_types;
enum bt_component_class_type type;
struct bt_notification_iterator_private_connection *iterator = NULL;
- assert(upstream_comp);
- assert(upstream_port);
- assert(notification_types);
- assert(bt_port_is_connected(upstream_port));
- assert(user_iterator);
+ BT_ASSERT(upstream_comp);
+ BT_ASSERT(upstream_port);
+ BT_ASSERT(notification_types);
+ BT_ASSERT(bt_port_is_connected(upstream_port));
+ BT_ASSERT(user_iterator);
BT_LOGD("Creating notification iterator on private connection: "
"upstream-comp-addr=%p, upstream-comp-name=\"%s\", "
"upstream-port-addr=%p, upstream-port-name=\"%s\", "
upstream_port, bt_port_get_name(upstream_port),
connection);
type = bt_component_get_class_type(upstream_comp);
- assert(type == BT_COMPONENT_CLASS_TYPE_SOURCE ||
+ BT_ASSERT(type == BT_COMPONENT_CLASS_TYPE_SOURCE ||
type == BT_COMPONENT_CLASS_TYPE_FILTER);
iterator = g_new0(struct bt_notification_iterator_private_connection, 1);
if (!iterator) {
struct bt_private_connection_private_notification_iterator *private_iterator)
{
struct bt_notification_iterator_private_connection *iterator =
- bt_private_connection_notification_iterator_from_private(private_iterator);
+ bt_private_connection_notification_iterator_borrow_from_private(private_iterator);
return iterator ? iterator->user_data : NULL;
}
enum bt_notification_iterator_status ret =
BT_NOTIFICATION_ITERATOR_STATUS_OK;
struct bt_notification_iterator_private_connection *iterator =
- bt_private_connection_notification_iterator_from_private(private_iterator);
+ bt_private_connection_notification_iterator_borrow_from_private(private_iterator);
if (!iterator) {
BT_LOGW_STR("Invalid parameter: notification iterator is NULL.");
bt_bool validate_notification(
struct bt_notification_iterator_private_connection *iterator,
struct bt_notification *notif,
- struct bt_ctf_stream *notif_stream,
- struct bt_ctf_packet *notif_packet)
+ struct bt_stream *notif_stream,
+ struct bt_packet *notif_packet)
{
bt_bool is_valid = BT_TRUE;
struct stream_state *stream_state;
struct bt_port *stream_comp_cur_port;
- assert(notif_stream);
+ BT_ASSERT(notif_stream);
stream_comp_cur_port =
- bt_ctf_stream_port_for_component(notif_stream,
+ bt_stream_port_for_component(notif_stream,
iterator->upstream_component);
if (!stream_comp_cur_port) {
/*
"iter-upstream-port-addr=%p, "
"iter-upstream-port-name=%s",
notif_stream,
- bt_ctf_stream_get_name(notif_stream),
+ bt_stream_get_name(notif_stream),
stream_comp_cur_port,
bt_port_get_name(stream_comp_cur_port),
iterator->upstream_port,
"stream-addr=%p, stream-name=\"%s\", "
"stream-state-addr=%p",
notif_stream,
- bt_ctf_stream_get_name(notif_stream), stream_state);
+ bt_stream_get_name(notif_stream), stream_state);
if (stream_state->is_ended) {
/*
BT_LOGW("Stream is already ended: "
"stream-addr=%p, stream-name=\"%s\"",
notif_stream,
- bt_ctf_stream_get_name(notif_stream));
+ bt_stream_get_name(notif_stream));
is_valid = BT_FALSE;
goto end;
}
BT_LOGW("Duplicate stream beginning notification: "
"stream-addr=%p, stream-name=\"%s\"",
notif_stream,
- bt_ctf_stream_get_name(notif_stream));
+ bt_stream_get_name(notif_stream));
is_valid = BT_FALSE;
goto end;
case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
"stream-addr=%p, stream-name=\"%s\", "
"packet-addr=%p",
notif_stream,
- bt_ctf_stream_get_name(notif_stream),
+ bt_stream_get_name(notif_stream),
notif_packet);
is_valid = BT_FALSE;
goto end;
.type = ACTION_TYPE_PUSH_NOTIF,
};
- assert(notif);
+ BT_ASSERT(notif);
if (!is_subscribed_to_notification_type(iterator, notif->type)) {
return;
static
int add_action_push_notif_stream_begin(
struct bt_notification_iterator_private_connection *iterator,
- struct bt_ctf_stream *stream)
+ struct bt_stream *stream)
{
int ret = 0;
struct bt_notification *stream_begin_notif = NULL;
goto end;
}
- assert(stream);
+ BT_ASSERT(stream);
stream_begin_notif = bt_notification_stream_begin_create(stream);
if (!stream_begin_notif) {
BT_LOGE_STR("Cannot create stream beginning notification.");
add_action_push_notif(iterator, stream_begin_notif);
BT_LOGV("Added \"push stream beginning notification\" action: "
"stream-addr=%p, stream-name=\"%s\"",
- stream, bt_ctf_stream_get_name(stream));
+ stream, bt_stream_get_name(stream));
goto end;
error:
static
int add_action_push_notif_stream_end(
struct bt_notification_iterator_private_connection *iterator,
- struct bt_ctf_stream *stream)
+ struct bt_stream *stream)
{
int ret = 0;
struct bt_notification *stream_end_notif = NULL;
goto end;
}
- assert(stream);
+ BT_ASSERT(stream);
stream_end_notif = bt_notification_stream_end_create(stream);
if (!stream_end_notif) {
BT_LOGE_STR("Cannot create stream end notification.");
add_action_push_notif(iterator, stream_end_notif);
BT_LOGV("Added \"push stream end notification\" action: "
"stream-addr=%p, stream-name=\"%s\"",
- stream, bt_ctf_stream_get_name(stream));
+ stream, bt_stream_get_name(stream));
goto end;
error:
static
int add_action_push_notif_packet_begin(
struct bt_notification_iterator_private_connection *iterator,
- struct bt_ctf_packet *packet)
+ struct bt_packet *packet)
{
int ret = 0;
struct bt_notification *packet_begin_notif = NULL;
goto end;
}
- assert(packet);
+ BT_ASSERT(packet);
packet_begin_notif = bt_notification_packet_begin_create(packet);
if (!packet_begin_notif) {
BT_LOGE_STR("Cannot create packet beginning notification.");
static
int add_action_push_notif_packet_end(
struct bt_notification_iterator_private_connection *iterator,
- struct bt_ctf_packet *packet)
+ struct bt_packet *packet)
{
int ret = 0;
struct bt_notification *packet_end_notif = NULL;
goto end;
}
- assert(packet);
+ BT_ASSERT(packet);
packet_end_notif = bt_notification_packet_end_create(packet);
if (!packet_end_notif) {
BT_LOGE_STR("Cannot create packet end notification.");
},
};
- assert(stream_state);
+ BT_ASSERT(stream_state);
add_action(iterator, &action);
BT_LOGV("Added \"set stream state's ended\" action: "
"stream-state-addr=%p", stream_state);
void add_action_set_stream_state_cur_packet(
struct bt_notification_iterator_private_connection *iterator,
struct stream_state *stream_state,
- struct bt_ctf_packet *packet)
+ struct bt_packet *packet)
{
struct action action = {
.type = ACTION_TYPE_SET_STREAM_STATE_CUR_PACKET,
},
};
- assert(stream_state);
+ BT_ASSERT(stream_state);
add_action(iterator, &action);
BT_LOGV("Added \"set stream state's current packet\" action: "
"stream-state-addr=%p, packet-addr=%p",
struct bt_notification_iterator_private_connection *iterator,
enum action_type type,
struct stream_state *stream_state,
- struct bt_ctf_clock_value *cur_begin,
+ struct bt_clock_value *cur_begin,
uint64_t cur_count)
{
struct action action = {
},
};
- assert(stream_state);
- assert(type == ACTION_TYPE_UPDATE_STREAM_STATE_DISCARDED_PACKETS ||
+ BT_ASSERT(stream_state);
+ BT_ASSERT(type == ACTION_TYPE_UPDATE_STREAM_STATE_DISCARDED_PACKETS ||
type == ACTION_TYPE_UPDATE_STREAM_STATE_DISCARDED_EVENTS);
add_action(iterator, &action);
if (type == ACTION_TYPE_UPDATE_STREAM_STATE_DISCARDED_PACKETS) {
int ensure_stream_state_exists(
struct bt_notification_iterator_private_connection *iterator,
struct bt_notification *stream_begin_notif,
- struct bt_ctf_stream *notif_stream,
+ struct bt_stream *notif_stream,
struct stream_state **_stream_state)
{
int ret = 0;
}
static
-struct bt_ctf_field *get_struct_field_uint(struct bt_ctf_field *struct_field,
+struct bt_field *get_struct_field_uint(struct bt_field *struct_field,
const char *field_name)
{
- struct bt_ctf_field *field = NULL;
- struct bt_ctf_field_type *ft = NULL;
+ struct bt_field *field = NULL;
+ struct bt_field_type *ft = NULL;
- field = bt_ctf_field_structure_get_field_by_name(struct_field,
+ field = bt_field_structure_get_field_by_name(struct_field,
field_name);
if (!field) {
BT_LOGV_STR("`%s` field does not exist.");
goto end;
}
- if (!bt_ctf_field_is_integer(field)) {
+ if (!bt_field_is_integer(field)) {
BT_LOGV("Skipping `%s` field because its type is not an integer field type: "
"field-addr=%p, ft-addr=%p, ft-id=%s", field_name,
- field, ft, bt_ctf_field_type_id_string(
- bt_ctf_field_type_get_type_id(ft)));
+ field, ft, bt_field_type_id_string(
+ bt_field_type_get_type_id(ft)));
BT_PUT(field);
goto end;
}
- ft = bt_ctf_field_get_type(field);
- assert(ft);
+ ft = bt_field_get_type(field);
+ BT_ASSERT(ft);
- if (bt_ctf_field_type_integer_is_signed(ft)) {
+ if (bt_field_type_integer_is_signed(ft)) {
BT_LOGV("Skipping `%s` integer field because its type is signed: "
"field-addr=%p, ft-addr=%p", field_name, field, ft);
BT_PUT(field);
}
static
-uint64_t get_packet_context_events_discarded(struct bt_ctf_packet *packet)
+uint64_t get_packet_context_events_discarded(struct bt_packet *packet)
{
- struct bt_ctf_field *packet_context = NULL;
- struct bt_ctf_field *field = NULL;
+ struct bt_field *packet_context = NULL;
+ struct bt_field *field = NULL;
uint64_t retval = -1ULL;
int ret;
- packet_context = bt_ctf_packet_get_context(packet);
+ packet_context = bt_packet_get_context(packet);
if (!packet_context) {
goto end;
}
goto end;
}
- assert(bt_ctf_field_is_integer(field));
- ret = bt_ctf_field_unsigned_integer_get_value(field, &retval);
+ BT_ASSERT(bt_field_is_integer(field));
+ ret = bt_field_unsigned_integer_get_value(field, &retval);
if (ret) {
BT_LOGV("Cannot get raw value of packet's context field's `events_discarded` integer field: "
"packet-addr=%p, field-addr=%p",
}
static
-uint64_t get_packet_context_packet_seq_num(struct bt_ctf_packet *packet)
+uint64_t get_packet_context_packet_seq_num(struct bt_packet *packet)
{
- struct bt_ctf_field *packet_context = NULL;
- struct bt_ctf_field *field = NULL;
+ struct bt_field *packet_context = NULL;
+ struct bt_field *field = NULL;
uint64_t retval = -1ULL;
int ret;
- packet_context = bt_ctf_packet_get_context(packet);
+ packet_context = bt_packet_get_context(packet);
if (!packet_context) {
goto end;
}
goto end;
}
- assert(bt_ctf_field_is_integer(field));
- ret = bt_ctf_field_unsigned_integer_get_value(field, &retval);
+ BT_ASSERT(bt_field_is_integer(field));
+ ret = bt_field_unsigned_integer_get_value(field, &retval);
if (ret) {
BT_LOGV("Cannot get raw value of packet's context field's `packet_seq_num` integer field: "
"packet-addr=%p, field-addr=%p",
static
int handle_discarded_packets(
struct bt_notification_iterator_private_connection *iterator,
- struct bt_ctf_packet *packet,
- struct bt_ctf_clock_value *ts_begin,
- struct bt_ctf_clock_value *ts_end,
+ struct bt_packet *packet,
+ struct bt_clock_value *ts_begin,
+ struct bt_clock_value *ts_end,
struct stream_state *stream_state)
{
struct bt_notification *notif = NULL;
static
int handle_discarded_events(
struct bt_notification_iterator_private_connection *iterator,
- struct bt_ctf_packet *packet,
- struct bt_ctf_clock_value *ts_begin,
- struct bt_ctf_clock_value *ts_end,
+ struct bt_packet *packet,
+ struct bt_clock_value *ts_begin,
+ struct bt_clock_value *ts_end,
struct stream_state *stream_state)
{
struct bt_notification *notif = NULL;
}
static
-int get_field_clock_value(struct bt_ctf_field *root_field,
+int get_field_clock_value(struct bt_field *root_field,
const char *field_name,
- struct bt_ctf_clock_value **user_clock_val)
+ struct bt_clock_value **user_clock_val)
{
- struct bt_ctf_field *field;
- struct bt_ctf_field_type *ft = NULL;
- struct bt_ctf_clock_class *clock_class = NULL;
- struct bt_ctf_clock_value *clock_value = NULL;
+ struct bt_field *field;
+ struct bt_field_type *ft = NULL;
+ struct bt_clock_class *clock_class = NULL;
+ struct bt_clock_value *clock_value = NULL;
uint64_t val;
int ret = 0;
goto end;
}
- ft = bt_ctf_field_get_type(field);
- assert(ft);
- clock_class = bt_ctf_field_type_integer_get_mapped_clock_class(ft);
+ ft = bt_field_get_type(field);
+ BT_ASSERT(ft);
+ clock_class = bt_field_type_integer_get_mapped_clock_class(ft);
if (!clock_class) {
BT_LOGW("Integer field type has no mapped clock class but it's expected to have one: "
"ft-addr=%p", ft);
goto end;
}
- ret = bt_ctf_field_unsigned_integer_get_value(field, &val);
+ ret = bt_field_unsigned_integer_get_value(field, &val);
if (ret) {
BT_LOGW("Cannot get integer field's raw value: "
"field-addr=%p", field);
goto end;
}
- clock_value = bt_ctf_clock_value_create(clock_class, val);
+ clock_value = bt_clock_value_create(clock_class, val);
if (!clock_value) {
BT_LOGE_STR("Cannot create clock value from clock class.");
ret = -1;
}
static
-int get_ts_begin_ts_end_from_packet(struct bt_ctf_packet *packet,
- struct bt_ctf_clock_value **user_ts_begin,
- struct bt_ctf_clock_value **user_ts_end)
+int get_ts_begin_ts_end_from_packet(struct bt_packet *packet,
+ struct bt_clock_value **user_ts_begin,
+ struct bt_clock_value **user_ts_end)
{
- struct bt_ctf_field *packet_context = NULL;
- struct bt_ctf_clock_value *ts_begin = NULL;
- struct bt_ctf_clock_value *ts_end = NULL;
+ struct bt_field *packet_context = NULL;
+ struct bt_clock_value *ts_begin = NULL;
+ struct bt_clock_value *ts_end = NULL;
int ret = 0;
- packet_context = bt_ctf_packet_get_context(packet);
+ packet_context = bt_packet_get_context(packet);
if (!packet_context) {
goto end;
}
static
int handle_discarded_elements(
struct bt_notification_iterator_private_connection *iterator,
- struct bt_ctf_packet *packet, struct stream_state *stream_state)
+ struct bt_packet *packet, struct stream_state *stream_state)
{
- struct bt_ctf_clock_value *ts_begin = NULL;
- struct bt_ctf_clock_value *ts_end = NULL;
+ struct bt_clock_value *ts_begin = NULL;
+ struct bt_clock_value *ts_end = NULL;
int ret;
ret = get_ts_begin_ts_end_from_packet(packet, &ts_begin, &ts_end);
int handle_packet_switch(
struct bt_notification_iterator_private_connection *iterator,
struct bt_notification *packet_begin_notif,
- struct bt_ctf_packet *new_packet,
+ struct bt_packet *new_packet,
struct stream_state *stream_state)
{
int ret = 0;
int handle_notif_stream_begin(
struct bt_notification_iterator_private_connection *iterator,
struct bt_notification *notif,
- struct bt_ctf_stream *notif_stream)
+ struct bt_stream *notif_stream)
{
int ret = 0;
struct stream_state *stream_state;
- assert(notif->type == BT_NOTIFICATION_TYPE_STREAM_BEGIN);
- assert(notif_stream);
+ BT_ASSERT(notif->type == BT_NOTIFICATION_TYPE_STREAM_BEGIN);
+ BT_ASSERT(notif_stream);
ret = ensure_stream_state_exists(iterator, notif, notif_stream,
&stream_state);
if (ret) {
int handle_notif_stream_end(
struct bt_notification_iterator_private_connection *iterator,
struct bt_notification *notif,
- struct bt_ctf_stream *notif_stream)
+ struct bt_stream *notif_stream)
{
int ret = 0;
struct stream_state *stream_state;
- assert(notif->type == BT_NOTIFICATION_TYPE_STREAM_END);
- assert(notif_stream);
+ BT_ASSERT(notif->type == BT_NOTIFICATION_TYPE_STREAM_END);
+ BT_ASSERT(notif_stream);
ret = ensure_stream_state_exists(iterator, NULL, notif_stream,
&stream_state);
if (ret) {
int handle_notif_discarded_elements(
struct bt_notification_iterator_private_connection *iterator,
struct bt_notification *notif,
- struct bt_ctf_stream *notif_stream)
+ struct bt_stream *notif_stream)
{
int ret = 0;
struct stream_state *stream_state;
- assert(notif->type == BT_NOTIFICATION_TYPE_DISCARDED_EVENTS ||
+ BT_ASSERT(notif->type == BT_NOTIFICATION_TYPE_DISCARDED_EVENTS ||
notif->type == BT_NOTIFICATION_TYPE_DISCARDED_PACKETS);
- assert(notif_stream);
+ BT_ASSERT(notif_stream);
ret = ensure_stream_state_exists(iterator, NULL, notif_stream,
&stream_state);
if (ret) {
int handle_notif_packet_begin(
struct bt_notification_iterator_private_connection *iterator,
struct bt_notification *notif,
- struct bt_ctf_stream *notif_stream,
- struct bt_ctf_packet *notif_packet)
+ struct bt_stream *notif_stream,
+ struct bt_packet *notif_packet)
{
int ret = 0;
struct stream_state *stream_state;
- assert(notif->type == BT_NOTIFICATION_TYPE_PACKET_BEGIN);
- assert(notif_packet);
+ BT_ASSERT(notif->type == BT_NOTIFICATION_TYPE_PACKET_BEGIN);
+ BT_ASSERT(notif_packet);
ret = ensure_stream_state_exists(iterator, NULL, notif_stream,
&stream_state);
if (ret) {
int handle_notif_packet_end(
struct bt_notification_iterator_private_connection *iterator,
struct bt_notification *notif,
- struct bt_ctf_stream *notif_stream,
- struct bt_ctf_packet *notif_packet)
+ struct bt_stream *notif_stream,
+ struct bt_packet *notif_packet)
{
int ret = 0;
struct stream_state *stream_state;
- assert(notif->type == BT_NOTIFICATION_TYPE_PACKET_END);
- assert(notif_packet);
+ BT_ASSERT(notif->type == BT_NOTIFICATION_TYPE_PACKET_END);
+ BT_ASSERT(notif_packet);
ret = ensure_stream_state_exists(iterator, NULL, notif_stream,
&stream_state);
if (ret) {
int handle_notif_event(
struct bt_notification_iterator_private_connection *iterator,
struct bt_notification *notif,
- struct bt_ctf_stream *notif_stream,
- struct bt_ctf_packet *notif_packet)
+ struct bt_stream *notif_stream,
+ struct bt_packet *notif_packet)
{
int ret = 0;
struct stream_state *stream_state;
- assert(notif->type == BT_NOTIFICATION_TYPE_EVENT);
- assert(notif_packet);
+ BT_ASSERT(notif->type == BT_NOTIFICATION_TYPE_EVENT);
+ BT_ASSERT(notif_packet);
ret = ensure_stream_state_exists(iterator, NULL, notif_stream,
&stream_state);
if (ret) {
struct bt_notification *notif)
{
int ret = 0;
- struct bt_ctf_event *notif_event = NULL;
- struct bt_ctf_stream *notif_stream = NULL;
- struct bt_ctf_packet *notif_packet = NULL;
+ struct bt_event *notif_event = NULL;
+ struct bt_stream *notif_stream = NULL;
+ struct bt_packet *notif_packet = NULL;
- assert(notif);
+ BT_ASSERT(notif);
BT_LOGV("Enqueuing user notification and automatic notifications: "
"iter-addr=%p, notif-addr=%p", iterator, notif);
switch (notif->type) {
case BT_NOTIFICATION_TYPE_EVENT:
notif_event = bt_notification_event_borrow_event(notif);
- assert(notif_event);
- notif_packet = bt_ctf_event_borrow_packet(notif_event);
- assert(notif_packet);
+ BT_ASSERT(notif_event);
+ notif_packet = bt_event_borrow_packet(notif_event);
+ BT_ASSERT(notif_packet);
break;
case BT_NOTIFICATION_TYPE_STREAM_BEGIN:
notif_stream =
bt_notification_stream_begin_borrow_stream(notif);
- assert(notif_stream);
+ BT_ASSERT(notif_stream);
break;
case BT_NOTIFICATION_TYPE_STREAM_END:
notif_stream = bt_notification_stream_end_borrow_stream(notif);
- assert(notif_stream);
+ BT_ASSERT(notif_stream);
break;
case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
notif_packet =
bt_notification_packet_begin_borrow_packet(notif);
- assert(notif_packet);
+ BT_ASSERT(notif_packet);
break;
case BT_NOTIFICATION_TYPE_PACKET_END:
notif_packet = bt_notification_packet_end_borrow_packet(notif);
- assert(notif_packet);
+ BT_ASSERT(notif_packet);
break;
case BT_NOTIFICATION_TYPE_INACTIVITY:
/* Always valid */
}
if (notif_packet) {
- notif_stream = bt_ctf_packet_borrow_stream(notif_packet);
- assert(notif_stream);
+ notif_stream = bt_packet_borrow_stream(notif_packet);
+ BT_ASSERT(notif_stream);
}
if (!notif_stream) {
&stream_state_gptr)) {
struct stream_state *stream_state = stream_state_gptr;
- assert(stream_state_gptr);
+ BT_ASSERT(stream_state_gptr);
if (stream_state->is_ended) {
continue;
BT_NOTIFICATION_ITERATOR_STATUS_OK;
int ret;
- assert(iterator);
+ BT_ASSERT(iterator);
BT_LOGD("Ensuring that notification iterator's queue has at least one notification: "
"iter-addr=%p, queue-size=%u, iter-state=%s",
iterator, iterator->queue->length,
break;
}
- assert(iterator->upstream_component);
- assert(iterator->upstream_component->class);
+ BT_ASSERT(iterator->upstream_component);
+ BT_ASSERT(iterator->upstream_component->class);
/* Pick the appropriate "next" method */
switch (iterator->upstream_component->class->type) {
container_of(iterator->upstream_component->class,
struct bt_component_class_source, parent);
- assert(source_class->methods.iterator.next);
+ BT_ASSERT(source_class->methods.iterator.next);
next_method = source_class->methods.iterator.next;
break;
}
container_of(iterator->upstream_component->class,
struct bt_component_class_filter, parent);
- assert(filter_class->methods.iterator.next);
+ BT_ASSERT(filter_class->methods.iterator.next);
next_method = filter_class->methods.iterator.next;
break;
}
* Call the user's "next" method to get the next notification
* and status.
*/
- assert(next_method);
+ BT_ASSERT(next_method);
while (iterator->queue->length == 0) {
BT_LOGD_STR("Calling user's \"next\" method.");
goto end;
}
- assert(iterator->state ==
+ BT_ASSERT(iterator->state ==
BT_PRIVATE_CONNECTION_NOTIFICATION_ITERATOR_STATE_ACTIVE);
iterator->state = BT_PRIVATE_CONNECTION_NOTIFICATION_ITERATOR_STATE_ENDED;
* Move the notification at the tail of the queue to the
* iterator's current notification.
*/
- assert(priv_conn_iter->queue->length > 0);
+ BT_ASSERT(priv_conn_iter->queue->length > 0);
notif = g_queue_pop_tail(priv_conn_iter->queue);
bt_notification_iterator_replace_current_notification(
iterator, notif);
break;
case BT_GRAPH_STATUS_OK:
status = BT_NOTIFICATION_ITERATOR_STATUS_OK;
- assert(bt_notification_iterator_borrow_current_notification(iterator));
+ BT_ASSERT(bt_notification_iterator_borrow_current_notification(iterator));
break;
default:
/* Other errors */
{
return bt_private_component_from_component(
bt_private_connection_notification_iterator_get_component(
- (void *) bt_private_connection_notification_iterator_from_private(private_iterator)));
+ (void *) bt_private_connection_notification_iterator_borrow_from_private(private_iterator)));
}
static
}
graph = bt_component_get_graph(output_port_comp);
- assert(graph);
+ BT_ASSERT(graph);
/* Create notification iterator */
BT_LOGD("Creating notification iterator on output port: "
*/
colander_in_port = bt_component_sink_get_input_port_by_index(
iterator->colander, 0);
- assert(colander_in_port);
+ BT_ASSERT(colander_in_port);
graph_status = bt_graph_connect_ports(iterator->graph,
output_port, colander_in_port, NULL);
if (graph_status != BT_GRAPH_STATUS_OK) {
*/
ret = bt_graph_remove_unconnected_component(iterator->graph,
colander_comp);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
}
BT_PUT(iterator);
bt_put(graph);
return (void *) iterator;
}
+
+struct bt_notification_iterator *
+bt_private_connection_notification_iterator_from_private(
+ struct bt_private_connection_private_notification_iterator *private_notification_iterator)
+{
+ return bt_get(
+ bt_private_connection_notification_iterator_borrow_from_private(
+ private_notification_iterator));
+}
projects / babeltrace.git / blobdiff