enum bt_notification_type {
BT_NOTIFICATION_TYPE_EVENT = 0,
BT_NOTIFICATION_TYPE_INACTIVITY = 1,
- BT_NOTIFICATION_TYPE_STREAM_BEGIN = 2,
+ BT_NOTIFICATION_TYPE_STREAM_BEGINNING = 2,
BT_NOTIFICATION_TYPE_STREAM_END = 3,
- BT_NOTIFICATION_TYPE_PACKET_BEGIN = 4,
+ BT_NOTIFICATION_TYPE_PACKET_BEGINNING = 4,
BT_NOTIFICATION_TYPE_PACKET_END = 5,
};
/* Pool of `struct bt_notification_event *` */
struct bt_object_pool event_notif_pool;
- /* Pool of `struct bt_notification_packet_begin *` */
+ /* Pool of `struct bt_notification_packet_beginning *` */
struct bt_object_pool packet_begin_notif_pool;
/* Pool of `struct bt_notification_packet_end *` */
enum bt_notification_type {
BT_NOTIFICATION_TYPE_EVENT = 0,
BT_NOTIFICATION_TYPE_INACTIVITY = 1,
- BT_NOTIFICATION_TYPE_STREAM_BEGIN = 2,
+ BT_NOTIFICATION_TYPE_STREAM_BEGINNING = 2,
BT_NOTIFICATION_TYPE_STREAM_END = 3,
- BT_NOTIFICATION_TYPE_PACKET_BEGIN = 4,
+ BT_NOTIFICATION_TYPE_PACKET_BEGINNING = 4,
BT_NOTIFICATION_TYPE_PACKET_END = 5,
};
return "BT_NOTIFICATION_TYPE_EVENT";
case BT_NOTIFICATION_TYPE_INACTIVITY:
return "BT_NOTIFICATION_TYPE_INACTIVITY";
- case BT_NOTIFICATION_TYPE_STREAM_BEGIN:
- return "BT_NOTIFICATION_TYPE_STREAM_BEGIN";
+ case BT_NOTIFICATION_TYPE_STREAM_BEGINNING:
+ return "BT_NOTIFICATION_TYPE_STREAM_BEGINNING";
case BT_NOTIFICATION_TYPE_STREAM_END:
return "BT_NOTIFICATION_TYPE_STREAM_END";
- case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
- return "BT_NOTIFICATION_TYPE_PACKET_BEGIN";
+ case BT_NOTIFICATION_TYPE_PACKET_BEGINNING:
+ return "BT_NOTIFICATION_TYPE_PACKET_BEGINNING";
case BT_NOTIFICATION_TYPE_PACKET_END:
return "BT_NOTIFICATION_TYPE_PACKET_END";
default:
struct bt_notification;
struct bt_packet;
-extern const struct bt_packet *bt_notification_packet_begin_borrow_packet_const(
+extern const struct bt_packet *bt_notification_packet_beginning_borrow_packet_const(
const struct bt_notification *notification);
extern const struct bt_packet *bt_notification_packet_end_borrow_packet_const(
#include <babeltrace/graph/notification-internal.h>
#include <babeltrace/assert-internal.h>
-struct bt_notification_packet_begin {
+struct bt_notification_packet_beginning {
struct bt_notification parent;
struct bt_packet *packet;
};
};
BT_HIDDEN
-struct bt_notification *bt_notification_packet_begin_new(
+struct bt_notification *bt_notification_packet_beginning_new(
struct bt_graph *graph);
BT_HIDDEN
-void bt_notification_packet_begin_recycle(struct bt_notification *notif);
+void bt_notification_packet_beginning_recycle(struct bt_notification *notif);
BT_HIDDEN
-void bt_notification_packet_begin_destroy(struct bt_notification *notif);
+void bt_notification_packet_beginning_destroy(struct bt_notification *notif);
BT_HIDDEN
struct bt_notification *bt_notification_packet_end_new(struct bt_graph *graph);
struct bt_packet;
extern
-struct bt_notification *bt_notification_packet_begin_create(
+struct bt_notification *bt_notification_packet_beginning_create(
struct bt_self_notification_iterator *notification_iterator,
struct bt_packet *packet);
struct bt_self_notification_iterator *notification_iterator,
struct bt_packet *packet);
-extern struct bt_packet *bt_notification_packet_begin_borrow_packet(
+extern struct bt_packet *bt_notification_packet_beginning_borrow_packet(
struct bt_notification *notification);
extern struct bt_packet *bt_notification_packet_end_borrow_packet(
struct bt_clock_value;
struct bt_stream;
-extern const struct bt_stream *bt_notification_stream_begin_borrow_stream_const(
+extern const struct bt_stream *bt_notification_stream_beginning_borrow_stream_const(
const struct bt_notification *notification);
extern const struct bt_clock_value *
-bt_notification_stream_begin_borrow_default_clock_value_const(
+bt_notification_stream_beginning_borrow_default_clock_value_const(
const struct bt_notification *notif);
extern const struct bt_stream *bt_notification_stream_end_borrow_stream_const(
#include <babeltrace/trace-ir/clock-value-internal.h>
#include <babeltrace/assert-internal.h>
-struct bt_notification_stream_begin {
+struct bt_notification_stream_beginning {
struct bt_notification parent;
struct bt_stream *stream;
struct bt_clock_value *default_cv;
struct bt_stream;
extern
-struct bt_notification *bt_notification_stream_begin_create(
+struct bt_notification *bt_notification_stream_beginning_create(
struct bt_self_notification_iterator *notification_iterator,
struct bt_stream *stream);
struct bt_self_notification_iterator *notification_iterator,
struct bt_stream *stream);
-extern struct bt_stream *bt_notification_stream_begin_borrow_stream(
+extern struct bt_stream *bt_notification_stream_beginning_borrow_stream(
struct bt_notification *notification);
-extern void bt_notification_stream_begin_set_default_clock_value(
+extern void bt_notification_stream_beginning_set_default_clock_value(
struct bt_notification *notif, uint64_t value_cycles);
extern struct bt_stream *bt_notification_stream_end_borrow_stream(
void destroy_notification_packet_begin(struct bt_notification *notif,
struct bt_graph *graph)
{
- bt_notification_packet_begin_destroy(notif);
+ bt_notification_packet_beginning_destroy(notif);
}
static
}
ret = bt_object_pool_initialize(&graph->packet_begin_notif_pool,
- (bt_object_pool_new_object_func) bt_notification_packet_begin_new,
+ (bt_object_pool_new_object_func) bt_notification_packet_beginning_new,
(bt_object_pool_destroy_object_func) destroy_notification_packet_begin,
graph);
if (ret) {
bt_notification_event_borrow_event_const(notif));
*stream = bt_packet_borrow_stream_const(*packet);
break;
- case BT_NOTIFICATION_TYPE_STREAM_BEGIN:
- *stream = bt_notification_stream_begin_borrow_stream_const(notif);
+ case BT_NOTIFICATION_TYPE_STREAM_BEGINNING:
+ *stream = bt_notification_stream_beginning_borrow_stream_const(notif);
break;
case BT_NOTIFICATION_TYPE_STREAM_END:
*stream = bt_notification_stream_end_borrow_stream_const(notif);
break;
- case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
- *packet = bt_notification_packet_begin_borrow_packet_const(notif);
+ case BT_NOTIFICATION_TYPE_PACKET_BEGINNING:
+ *packet = bt_notification_packet_beginning_borrow_packet_const(notif);
*stream = bt_packet_borrow_stream_const(*packet);
break;
case BT_NOTIFICATION_TYPE_PACKET_END:
if (!stream_state) {
/*
* No stream state for this stream: this notification
- * MUST be a BT_NOTIFICATION_TYPE_STREAM_BEGIN notification
+ * MUST be a BT_NOTIFICATION_TYPE_STREAM_BEGINNING notification
* and its sequence number must be 0.
*/
- if (c_notif->type != BT_NOTIFICATION_TYPE_STREAM_BEGIN) {
+ if (c_notif->type != BT_NOTIFICATION_TYPE_STREAM_BEGINNING) {
BT_ASSERT_PRE_MSG("Unexpected notification: missing a "
- "BT_NOTIFICATION_TYPE_STREAM_BEGIN "
+ "BT_NOTIFICATION_TYPE_STREAM_BEGINNING "
"notification prior to this notification: "
"%![stream-]+s", stream);
is_valid = false;
}
switch (c_notif->type) {
- case BT_NOTIFICATION_TYPE_STREAM_BEGIN:
- BT_ASSERT_PRE_MSG("Unexpected BT_NOTIFICATION_TYPE_STREAM_BEGIN "
+ case BT_NOTIFICATION_TYPE_STREAM_BEGINNING:
+ BT_ASSERT_PRE_MSG("Unexpected BT_NOTIFICATION_TYPE_STREAM_BEGINNING "
"notification at this point: notif-seq-num=%" PRIu64 ", "
"%![stream-]+s", c_notif->seq_num, stream);
is_valid = false;
stream_state->expected_notif_seq_num++;
stream_state->is_ended = true;
goto end;
- case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
+ case BT_NOTIFICATION_TYPE_PACKET_BEGINNING:
if (stream_state->cur_packet) {
- BT_ASSERT_PRE_MSG("Unexpected BT_NOTIFICATION_TYPE_PACKET_BEGIN "
+ BT_ASSERT_PRE_MSG("Unexpected BT_NOTIFICATION_TYPE_PACKET_BEGINNING "
"notification at this point: missing a "
"BT_NOTIFICATION_TYPE_PACKET_END notification "
"prior to this notification: "
if (!stream_state->cur_packet) {
BT_ASSERT_PRE_MSG("Unexpected BT_NOTIFICATION_TYPE_PACKET_END "
"notification at this point: missing a "
- "BT_NOTIFICATION_TYPE_PACKET_BEGIN notification "
+ "BT_NOTIFICATION_TYPE_PACKET_BEGINNING notification "
"prior to this notification: "
"notif-seq-num=%" PRIu64 ", %![stream-]+s, "
"%![packet-]+a", c_notif->seq_num, stream,
#include <inttypes.h>
BT_HIDDEN
-struct bt_notification *bt_notification_packet_begin_new(struct bt_graph *graph)
+struct bt_notification *bt_notification_packet_beginning_new(struct bt_graph *graph)
{
- struct bt_notification_packet_begin *notification;
+ struct bt_notification_packet_beginning *notification;
- notification = g_new0(struct bt_notification_packet_begin, 1);
+ notification = g_new0(struct bt_notification_packet_beginning, 1);
if (!notification) {
BT_LOGE_STR("Failed to allocate one packet beginning notification.");
goto error;
}
bt_notification_init(¬ification->parent,
- BT_NOTIFICATION_TYPE_PACKET_BEGIN,
- (bt_object_release_func) bt_notification_packet_begin_recycle,
+ BT_NOTIFICATION_TYPE_PACKET_BEGINNING,
+ (bt_object_release_func) bt_notification_packet_beginning_recycle,
graph);
goto end;
return (void *) notification;
}
-struct bt_notification *bt_notification_packet_begin_create(
+struct bt_notification *bt_notification_packet_beginning_create(
struct bt_self_notification_iterator *self_notif_iter,
struct bt_packet *packet)
{
struct bt_self_component_port_input_notification_iterator *notif_iter =
(void *) self_notif_iter;
- struct bt_notification_packet_begin *notification = NULL;
+ struct bt_notification_packet_beginning *notification = NULL;
struct bt_stream *stream;
struct bt_stream_class *stream_class;
}
BT_HIDDEN
-void bt_notification_packet_begin_destroy(struct bt_notification *notif)
+void bt_notification_packet_beginning_destroy(struct bt_notification *notif)
{
- struct bt_notification_packet_begin *packet_begin_notif = (void *) notif;
+ struct bt_notification_packet_beginning *packet_begin_notif = (void *) notif;
BT_LIB_LOGD("Destroying packet beginning notification: %!+n", notif);
BT_LIB_LOGD("Putting packet: %!+a", packet_begin_notif->packet);
}
BT_HIDDEN
-void bt_notification_packet_begin_recycle(struct bt_notification *notif)
+void bt_notification_packet_beginning_recycle(struct bt_notification *notif)
{
- struct bt_notification_packet_begin *packet_begin_notif = (void *) notif;
+ struct bt_notification_packet_beginning *packet_begin_notif = (void *) notif;
struct bt_graph *graph;
BT_ASSERT(packet_begin_notif);
if (unlikely(!notif->graph)) {
- bt_notification_packet_begin_destroy(notif);
+ bt_notification_packet_beginning_destroy(notif);
return;
}
bt_object_pool_recycle_object(&graph->packet_begin_notif_pool, notif);
}
-struct bt_packet *bt_notification_packet_begin_borrow_packet(
+struct bt_packet *bt_notification_packet_beginning_borrow_packet(
struct bt_notification *notification)
{
- struct bt_notification_packet_begin *packet_begin;
+ struct bt_notification_packet_beginning *packet_begin;
BT_ASSERT_PRE_NON_NULL(notification, "Notification");
BT_ASSERT_PRE_NOTIF_IS_TYPE(notification,
- BT_NOTIFICATION_TYPE_PACKET_BEGIN);
+ BT_NOTIFICATION_TYPE_PACKET_BEGINNING);
packet_begin = (void *) notification;
return packet_begin->packet;
}
-const struct bt_packet *bt_notification_packet_begin_borrow_packet_const(
+const struct bt_packet *bt_notification_packet_beginning_borrow_packet_const(
const struct bt_notification *notification)
{
- return bt_notification_packet_begin_borrow_packet(
+ return bt_notification_packet_beginning_borrow_packet(
(void *) notification);
}
}
static
-void bt_notification_stream_begin_destroy(struct bt_object *obj)
+void bt_notification_stream_beginning_destroy(struct bt_object *obj)
{
- struct bt_notification_stream_begin *notification =
- (struct bt_notification_stream_begin *) obj;
+ struct bt_notification_stream_beginning *notification =
+ (struct bt_notification_stream_beginning *) obj;
BT_LIB_LOGD("Destroying stream beginning notification: %!+n",
notification);
g_free(notification);
}
-struct bt_notification *bt_notification_stream_begin_create(
+struct bt_notification *bt_notification_stream_beginning_create(
struct bt_self_notification_iterator *self_notif_iter,
struct bt_stream *stream)
{
- struct bt_notification_stream_begin *notification;
+ struct bt_notification_stream_beginning *notification;
struct bt_stream_class *stream_class;
BT_ASSERT_PRE_NON_NULL(self_notif_iter, "Notification iterator");
BT_ASSERT(stream_class);
BT_LIB_LOGD("Creating stream beginning notification object: "
"%![stream-]+s, %![sc-]+S", stream, stream_class);
- notification = g_new0(struct bt_notification_stream_begin, 1);
+ notification = g_new0(struct bt_notification_stream_beginning, 1);
if (!notification) {
BT_LOGE_STR("Failed to allocate one stream beginning notification.");
goto error;
}
bt_notification_init(¬ification->parent,
- BT_NOTIFICATION_TYPE_STREAM_BEGIN,
- bt_notification_stream_begin_destroy, NULL);
+ BT_NOTIFICATION_TYPE_STREAM_BEGINNING,
+ bt_notification_stream_beginning_destroy, NULL);
notification->stream = stream;
bt_object_get_no_null_check(notification->stream);
BT_LIB_LOGD("Created stream beginning notification object: "
return NULL;
}
-struct bt_stream *bt_notification_stream_begin_borrow_stream(
+struct bt_stream *bt_notification_stream_beginning_borrow_stream(
struct bt_notification *notification)
{
- struct bt_notification_stream_begin *stream_begin;
+ struct bt_notification_stream_beginning *stream_begin;
BT_ASSERT_PRE_NON_NULL(notification, "Notification");
BT_ASSERT_PRE_NOTIF_IS_TYPE(notification,
- BT_NOTIFICATION_TYPE_STREAM_BEGIN);
+ BT_NOTIFICATION_TYPE_STREAM_BEGINNING);
stream_begin = (void *) notification;
return stream_begin->stream;
}
-const struct bt_stream *bt_notification_stream_begin_borrow_stream_const(
+const struct bt_stream *bt_notification_stream_beginning_borrow_stream_const(
const struct bt_notification *notification)
{
- return bt_notification_stream_begin_borrow_stream(
+ return bt_notification_stream_beginning_borrow_stream(
(void *) notification);
}
-void bt_notification_stream_begin_set_default_clock_value(
+void bt_notification_stream_beginning_set_default_clock_value(
struct bt_notification *notif,
uint64_t value_cycles)
{
- struct bt_notification_stream_begin *sb_notif = (void *) notif;
+ struct bt_notification_stream_beginning *sb_notif = (void *) notif;
BT_ASSERT_PRE_NON_NULL(notif, "Notification");
BT_ASSERT_PRE_HOT(notif, "Notification", ": %!+n", notif);
- BT_ASSERT_PRE_NOTIF_IS_TYPE(notif, BT_NOTIFICATION_TYPE_STREAM_BEGIN);
+ BT_ASSERT_PRE_NOTIF_IS_TYPE(notif, BT_NOTIFICATION_TYPE_STREAM_BEGINNING);
BT_ASSERT_PRE(sb_notif->stream->class->default_clock_class,
"Notification's stream class has no default clock class: "
"%![notif-]+n, %![sc-]+S", notif, sb_notif->stream->class);
"value=%" PRIu64, value_cycles);
}
-struct bt_clock_value *bt_notification_stream_begin_borrow_default_clock_value(
+struct bt_clock_value *bt_notification_stream_beginning_borrow_default_clock_value(
struct bt_notification *notif)
{
- struct bt_notification_stream_begin *stream_begin = (void *) notif;
+ struct bt_notification_stream_beginning *stream_begin = (void *) notif;
BT_ASSERT_PRE_NON_NULL(notif, "Notification");
- BT_ASSERT_PRE_NOTIF_IS_TYPE(notif, BT_NOTIFICATION_TYPE_STREAM_BEGIN);
+ BT_ASSERT_PRE_NOTIF_IS_TYPE(notif, BT_NOTIFICATION_TYPE_STREAM_BEGINNING);
return stream_begin->default_cv;
}
break;
}
- case BT_NOTIFICATION_TYPE_STREAM_BEGIN:
+ case BT_NOTIFICATION_TYPE_STREAM_BEGINNING:
{
- const struct bt_notification_stream_begin *notif_stream =
+ const struct bt_notification_stream_beginning *notif_stream =
(const void *) notif;
if (notif_stream->stream) {
break;
}
- case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
+ case BT_NOTIFICATION_TYPE_PACKET_BEGINNING:
{
- const struct bt_notification_packet_begin *notif_packet =
+ const struct bt_notification_packet_beginning *notif_packet =
(const void *) notif;
if (notif_packet->packet) {
BT_ASSERT(notit->stream);
BT_ASSERT(notit->notif_iter);
- ret = bt_notification_stream_begin_create(notit->notif_iter,
+ ret = bt_notification_stream_beginning_create(notit->notif_iter,
notit->stream);
if (!ret) {
BT_LOGE("Cannot create stream beginning notification: "
}
BT_ASSERT(notit->notif_iter);
- notif = bt_notification_packet_begin_create(notit->notif_iter,
+ notif = bt_notification_packet_beginning_create(notit->notif_iter,
notit->packet);
if (!notif) {
BT_LOGE("Cannot create packet beginning notification: "
* Resets the iterator so that the next requested medium bytes are
* assumed to be the first bytes of a new stream. The first notification
* which this iterator emits after calling bt_notif_iter_reset() is a
- * BT_NOTIFICATION_TYPE_STREAM_BEGIN one.
+ * BT_NOTIFICATION_TYPE_STREAM_BEGINNING one.
*/
BT_HIDDEN
void bt_notif_iter_reset(struct bt_notif_iter *notit);
}
switch (bt_notification_get_type(notification)) {
- case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
+ case BT_NOTIFICATION_TYPE_PACKET_BEGINNING:
{
const struct bt_packet *packet =
- bt_notification_packet_begin_get_packet(notification);
+ bt_notification_packet_beginning_get_packet(notification);
if (!packet) {
ret = BT_COMPONENT_STATUS_ERROR;
}
break;
}
- case BT_NOTIFICATION_TYPE_STREAM_BEGIN:
+ case BT_NOTIFICATION_TYPE_STREAM_BEGINNING:
{
const struct bt_stream *stream =
- bt_notification_stream_begin_get_stream(notification);
+ bt_notification_stream_beginning_get_stream(notification);
if (!stream) {
ret = BT_COMPONENT_STATUS_ERROR;
if (status == BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK &&
bt_notification_get_type(*notif) ==
- BT_NOTIFICATION_TYPE_STREAM_BEGIN) {
+ BT_NOTIFICATION_TYPE_STREAM_BEGINNING) {
if (notif_iter_data->skip_stream_begin_notifs) {
/*
* We already emitted a
- * BT_NOTIFICATION_TYPE_STREAM_BEGIN
+ * BT_NOTIFICATION_TYPE_STREAM_BEGINNING
* notification: skip this one, get a new one.
*/
BT_OBJECT_PUT_REF_AND_RESET(*notif);
goto end;
} else {
/*
- * First BT_NOTIFICATION_TYPE_STREAM_BEGIN
+ * First BT_NOTIFICATION_TYPE_STREAM_BEGINNING
* notification: skip all following.
*/
notif_iter_data->skip_stream_begin_notifs = true;
/*
* If we get a notification, we expect to get a
- * BT_NOTIFICATION_TYPE_STREAM_BEGIN notification
+ * BT_NOTIFICATION_TYPE_STREAM_BEGINNING notification
* because the iterator's state machine emits one before
* even requesting the first block of data from the
* medium. Skip this notification because we're not
* really starting a new stream here, and try getting a
* new notification (which, if it works, is a
- * BT_NOTIFICATION_TYPE_PACKET_BEGIN one). We're sure to
+ * BT_NOTIFICATION_TYPE_PACKET_BEGINNING one). We're sure to
* get at least one pair of
- * BT_NOTIFICATION_TYPE_PACKET_BEGIN and
+ * BT_NOTIFICATION_TYPE_PACKET_BEGINNING and
* BT_NOTIFICATION_TYPE_PACKET_END notifications in the
* case of a single, empty packet. We know there's at
* least one packet because the stream file group does
if (status == BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK) {
BT_ASSERT(bt_notification_get_type(*notif) ==
- BT_NOTIFICATION_TYPE_STREAM_BEGIN);
+ BT_NOTIFICATION_TYPE_STREAM_BEGINNING);
BT_OBJECT_PUT_REF_AND_RESET(*notif);
status = ctf_fs_ds_file_next(notif_iter_data->ds_file,
&priv_notif);
/* Owned by this */
struct bt_notif_iter *notif_iter;
- /* True to skip BT_NOTIFICATION_TYPE_STREAM_BEGIN notifications */
+ /* True to skip BT_NOTIFICATION_TYPE_STREAM_BEGINNING notifications */
bool skip_stream_begin_notifs;
};
const struct bt_notification *new_notification = NULL;
switch (bt_notification_get_type(notification)) {
- case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
+ case BT_NOTIFICATION_TYPE_PACKET_BEGINNING:
{
const struct bt_packet *packet =
- bt_notification_packet_begin_get_packet(notification);
+ bt_notification_packet_beginning_get_packet(notification);
const struct bt_packet *writer_packet;
if (!packet) {
writer_packet = debug_info_new_packet(debug_it, packet);
BT_ASSERT(writer_packet);
- new_notification = bt_notification_packet_begin_create(
+ new_notification = bt_notification_packet_beginning_create(
writer_packet);
BT_ASSERT(new_notification);
bt_object_put_ref(packet);
bt_object_put_ref(writer_event);
break;
}
- case BT_NOTIFICATION_TYPE_STREAM_BEGIN:
+ case BT_NOTIFICATION_TYPE_STREAM_BEGINNING:
{
const struct bt_stream *stream =
- bt_notification_stream_begin_get_stream(notification);
+ bt_notification_stream_beginning_get_stream(notification);
const struct bt_stream *writer_stream;
if (!stream) {
writer_stream = debug_info_stream_begin(debug_it, stream);
BT_ASSERT(writer_stream);
- new_notification = bt_notification_stream_begin_create(
+ new_notification = bt_notification_stream_beginning_create(
writer_stream);
BT_ASSERT(new_notification);
bt_object_put_ref(stream);
switch (dmesg_notif_iter->state) {
case STATE_EMIT_STREAM_BEGINNING:
BT_ASSERT(dmesg_notif_iter->tmp_event_notif);
- *notif = bt_notification_stream_begin_create(
+ *notif = bt_notification_stream_beginning_create(
dmesg_notif_iter->pc_notif_iter, dmesg_comp->stream);
dmesg_notif_iter->state = STATE_EMIT_PACKET_BEGINNING;
break;
case STATE_EMIT_PACKET_BEGINNING:
BT_ASSERT(dmesg_notif_iter->tmp_event_notif);
- *notif = bt_notification_packet_begin_create(
+ *notif = bt_notification_packet_beginning_create(
dmesg_notif_iter->pc_notif_iter, dmesg_comp->packet);
dmesg_notif_iter->state = STATE_EMIT_EVENT;
break;
BT_ASSERT(pretty);
switch (bt_notification_get_type(notification)) {
- case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
+ case BT_NOTIFICATION_TYPE_PACKET_BEGINNING:
if (pretty_print_packet(pretty, notification)) {
ret = BT_SELF_COMPONENT_STATUS_ERROR;
}
const struct bt_notification *packet_beginning_notif)
{
#if 0
- const struct bt_packet *packet = bt_notification_packet_begin_borrow_packet_const(
+ const struct bt_packet *packet = bt_notification_packet_beginning_borrow_packet_const(
packet_beginning_notif);
uint64_t count;
int status = 0;
case BT_NOTIFICATION_TYPE_INACTIVITY:
counter->count.inactivity++;
break;
- case BT_NOTIFICATION_TYPE_STREAM_BEGIN:
+ case BT_NOTIFICATION_TYPE_STREAM_BEGINNING:
counter->count.stream_begin++;
break;
case BT_NOTIFICATION_TYPE_STREAM_END:
counter->count.stream_end++;
break;
- case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
+ case BT_NOTIFICATION_TYPE_PACKET_BEGINNING:
counter->count.packet_begin++;
break;
case BT_NOTIFICATION_TYPE_PACKET_END:
bool lazy_update = false;
switch (bt_notification_get_type(notification)) {
- case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
- packet = bt_notification_packet_begin_get_packet(notification);
+ case BT_NOTIFICATION_TYPE_PACKET_BEGINNING:
+ packet = bt_notification_packet_beginning_get_packet(notification);
BT_ASSERT(packet);
writer_packet = trimmer_new_packet(trim_it, packet);
BT_ASSERT(writer_packet);
end:
switch (bt_notification_get_type(notification)) {
- case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
- new_notification = bt_notification_packet_begin_create(writer_packet);
+ case BT_NOTIFICATION_TYPE_PACKET_BEGINNING:
+ new_notification = bt_notification_packet_beginning_create(writer_packet);
BT_ASSERT(new_notification);
break;
case BT_NOTIFICATION_TYPE_PACKET_END:
new_notification = evaluate_event_notification(*notification,
trim_it, begin, end, in_range, &finished);
break;
- case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
+ case BT_NOTIFICATION_TYPE_PACKET_BEGINNING:
case BT_NOTIFICATION_TYPE_PACKET_END:
new_notification = evaluate_packet_notification(*notification,
trim_it, begin, end, in_range, &finished);
switch (user_data->seq[user_data->at]) {
case SEQ_STREAM1_BEGIN:
- *notif = bt_notification_stream_begin_create(notif_iter,
+ *notif = bt_notification_stream_beginning_create(notif_iter,
src_stream1);
break;
case SEQ_STREAM2_BEGIN:
- *notif = bt_notification_stream_begin_create(notif_iter,
+ *notif = bt_notification_stream_beginning_create(notif_iter,
src_stream2);
break;
case SEQ_STREAM1_END:
src_stream2);
break;
case SEQ_STREAM1_PACKET1_BEGIN:
- *notif = bt_notification_packet_begin_create(notif_iter,
+ *notif = bt_notification_packet_beginning_create(notif_iter,
src_stream1_packet1);
break;
case SEQ_STREAM1_PACKET2_BEGIN:
- *notif = bt_notification_packet_begin_create(notif_iter,
+ *notif = bt_notification_packet_beginning_create(notif_iter,
src_stream1_packet2);
break;
case SEQ_STREAM2_PACKET1_BEGIN:
- *notif = bt_notification_packet_begin_create(notif_iter,
+ *notif = bt_notification_packet_beginning_create(notif_iter,
src_stream2_packet1);
break;
case SEQ_STREAM2_PACKET2_BEGIN:
- *notif = bt_notification_packet_begin_create(notif_iter,
+ *notif = bt_notification_packet_beginning_create(notif_iter,
src_stream2_packet2);
break;
case SEQ_STREAM1_PACKET1_END:
BT_ASSERT(test_event.packet);
break;
}
- case BT_NOTIFICATION_TYPE_STREAM_BEGIN:
+ case BT_NOTIFICATION_TYPE_STREAM_BEGINNING:
test_event.type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN;
test_event.stream =
- bt_notification_stream_begin_borrow_stream_const(notification);
+ bt_notification_stream_beginning_borrow_stream_const(notification);
BT_ASSERT(test_event.stream);
break;
case BT_NOTIFICATION_TYPE_STREAM_END:
bt_notification_stream_end_borrow_stream_const(notification);
BT_ASSERT(test_event.stream);
break;
- case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
+ case BT_NOTIFICATION_TYPE_PACKET_BEGINNING:
test_event.type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN;
test_event.packet =
- bt_notification_packet_begin_borrow_packet_const(notification);
+ bt_notification_packet_beginning_borrow_packet_const(notification);
BT_ASSERT(test_event.packet);
break;
case BT_NOTIFICATION_TYPE_PACKET_END: