/* Owned by this, NULL if ended */
struct bt_notification_iterator *notif_iter;
+ /* Owned by this */
+ struct bt_notification *notif;
+
/*
* This flag is true if the upstream notification iterator's
* current notification must be considered for the multiplexing
muxer_upstream_notif_iter->notif_iter,
muxer_upstream_notif_iter->is_valid);
bt_put(muxer_upstream_notif_iter->notif_iter);
+ bt_put(muxer_upstream_notif_iter->notif);
g_free(muxer_upstream_notif_iter);
}
goto error;
}
- assume_absolute_clock_classes = bt_value_map_get(real_params,
+ assume_absolute_clock_classes = bt_value_map_borrow(real_params,
ASSUME_ABSOLUTE_CLOCK_CLASSES_PARAM_NAME);
if (assume_absolute_clock_classes &&
!bt_value_is_bool(assume_absolute_clock_classes)) {
end:
bt_put(default_params);
bt_put(real_params);
- bt_put(assume_absolute_clock_classes);
return ret;
}
struct bt_notification_iterator *create_notif_iter_on_input_port(
struct bt_private_port *priv_port, int *ret)
{
- struct bt_port *port = bt_port_from_private(priv_port);
+ struct bt_port *port = bt_port_borrow_from_private(priv_port);
struct bt_notification_iterator *notif_iter = NULL;
struct bt_private_connection *priv_conn = NULL;
enum bt_connection_status conn_status;
// returned notification by the muxer notification
// iterator which creates it.
conn_status = bt_private_connection_create_notification_iterator(
- priv_conn, NULL, ¬if_iter);
+ priv_conn, ¬if_iter);
if (conn_status != BT_CONNECTION_STATUS_OK) {
BT_LOGE("Cannot create upstream notification iterator on input port's connection: "
"port-addr=%p, port-name=\"%s\", conn-addr=%p, "
port, bt_port_get_name(port), priv_conn, notif_iter);
end:
- bt_put(port);
bt_put(priv_conn);
return notif_iter;
}
struct muxer_upstream_notif_iter *muxer_upstream_notif_iter)
{
enum bt_notification_iterator_status status;
+ struct bt_notification *notif = NULL;
BT_LOGV("Calling upstream notification iterator's \"next\" method: "
"muxer-upstream-notif-iter-wrap-addr=%p, notif-iter-addr=%p",
muxer_upstream_notif_iter,
muxer_upstream_notif_iter->notif_iter);
- status = bt_notification_iterator_next(
- muxer_upstream_notif_iter->notif_iter);
+ status = bt_private_connection_notification_iterator_next(
+ muxer_upstream_notif_iter->notif_iter, ¬if);
BT_LOGV("Upstream notification iterator's \"next\" method returned: "
"status=%s", bt_notification_iterator_status_string(status));
*/
BT_LOGV_STR("Validated upstream notification iterator wrapper.");
muxer_upstream_notif_iter->is_valid = true;
+ BT_MOVE(muxer_upstream_notif_iter->notif, notif);
break;
case BT_NOTIFICATION_ITERATOR_STATUS_AGAIN:
/*
break;
}
+ BT_ASSERT(!notif);
return status;
}
}
priv_port = node->data;
- port = bt_port_from_private(priv_port);
+ port = bt_port_borrow_from_private(priv_port);
BT_ASSERT(port);
if (!bt_port_is_connected(port)) {
goto remove_node;
}
- BT_PUT(port);
upstream_notif_iter = create_notif_iter_on_input_port(priv_port,
&ret);
if (ret) {
remove_node:
bt_put(upstream_notif_iter);
- bt_put(port);
muxer_notif_iter->newly_connected_priv_ports =
g_list_delete_link(
muxer_notif_iter->newly_connected_priv_ports,
switch (bt_notification_get_type(notif)) {
case BT_NOTIFICATION_TYPE_EVENT:
cc_prio_map =
- bt_notification_event_get_clock_class_priority_map(
+ bt_notification_event_borrow_clock_class_priority_map(
notif);
break;
case BT_NOTIFICATION_TYPE_INACTIVITY:
cc_prio_map =
- bt_notification_inactivity_get_clock_class_priority_map(
+ bt_notification_inactivity_borrow_clock_class_priority_map(
notif);
break;
default:
}
clock_class =
- bt_clock_class_priority_map_get_highest_priority_clock_class(
+ bt_clock_class_priority_map_borrow_highest_priority_clock_class(
cc_prio_map);
if (!clock_class) {
BT_LOGE("Cannot get the clock class with the highest priority from clock class priority map: "
switch (bt_notification_get_type(notif)) {
case BT_NOTIFICATION_TYPE_EVENT:
- event = bt_notification_event_get_event(notif);
+ event = bt_notification_event_borrow_event(notif);
BT_ASSERT(event);
- clock_value = bt_event_get_clock_value(event,
+ clock_value = bt_event_borrow_clock_value(event,
clock_class);
break;
case BT_NOTIFICATION_TYPE_INACTIVITY:
- clock_value = bt_notification_inactivity_get_clock_value(
+ clock_value = bt_notification_inactivity_borrow_clock_value(
notif, clock_class);
break;
default:
*ts_ns);
}
- bt_put(cc_prio_map);
- bt_put(event);
- bt_put(clock_class);
- bt_put(clock_value);
return ret;
}
}
BT_ASSERT(cur_muxer_upstream_notif_iter->is_valid);
- notif = bt_notification_iterator_get_notification(
- cur_muxer_upstream_notif_iter->notif_iter);
+ notif = cur_muxer_upstream_notif_iter->notif;
BT_ASSERT(notif);
ret = get_notif_ts_ns(muxer_comp, muxer_notif_iter, notif,
muxer_notif_iter->last_returned_ts_ns, ¬if_ts_ns);
- bt_put(notif);
if (ret) {
/* get_notif_ts_ns() logs errors */
*muxer_upstream_notif_iter = NULL;
muxer_notif_iter, muxer_upstream_notif_iter, next_return_ts);
BT_ASSERT(next_return.status == BT_NOTIFICATION_ITERATOR_STATUS_OK);
BT_ASSERT(muxer_upstream_notif_iter);
- next_return.notification = bt_notification_iterator_get_notification(
- muxer_upstream_notif_iter->notif_iter);
+ next_return.notification = bt_get(muxer_upstream_notif_iter->notif);
BT_ASSERT(next_return.notification);
/*
* iterator's list of newly connected ports. They will be
* handled by muxer_notif_iter_handle_newly_connected_ports().
*/
- comp = bt_component_from_private(muxer_comp->priv_comp);
+ comp = bt_component_borrow_from_private(muxer_comp->priv_comp);
BT_ASSERT(comp);
count = bt_component_filter_get_input_port_count(comp);
if (count < 0) {
struct bt_port *port;
BT_ASSERT(priv_port);
- port = bt_port_from_private(priv_port);
+ port = bt_port_borrow_from_private(priv_port);
BT_ASSERT(port);
if (!bt_port_is_connected(port)) {
"muxer-comp-addr=%p, port-addr=%p, port-name\"%s\"",
muxer_comp, port, bt_port_get_name(port));
bt_put(priv_port);
- bt_put(port);
continue;
}
- bt_put(port);
bt_put(priv_port);
muxer_notif_iter->newly_connected_priv_ports =
g_list_append(
}
end:
- bt_put(comp);
return ret;
}
struct bt_port *other_port)
{
struct bt_port *self_port =
- bt_port_from_private(self_private_port);
+ bt_port_borrow_from_private(self_private_port);
struct muxer_comp *muxer_comp =
bt_private_component_get_user_data(priv_comp);
size_t i;
}
end:
- bt_put(self_port);
+ return;
}
BT_HIDDEN
void muxer_port_disconnected(struct bt_private_component *priv_comp,
struct bt_private_port *priv_port)
{
- struct bt_port *port = bt_port_from_private(priv_port);
+ struct bt_port *port = bt_port_borrow_from_private(priv_port);
struct muxer_comp *muxer_comp =
bt_private_component_get_user_data(priv_comp);
priv_comp, muxer_comp, port, bt_port_get_name(port),
muxer_comp->available_input_ports);
}
-
- bt_put(port);
}